Skip to content

Changelog

Unreleased

Breaking changes

  • No Intel macOS wheels — 0.36 ships macOS wheels for arm64 (Apple silicon) only; 0.36.0.0rc1 was the last release with macosx_15_0_x86_64 wheels. Intel Macs can build from source. The include-intel-macos input of the wheels workflow and its macos-15-intel legs are gone.
  • pip install tesseract-robotics-nanobind installs the robot models; the [support] extra is gone — in rc1 tesseract-robotics-nanobind-support came only with [support], so a plain install had no package://tesseract/support/... robots and get_tesseract_resource_path() raised SupportDataNotFoundError. The bindings now depend on it, pinned == their own version; it stays a separate wheel so the ~40 MB of meshes, which rarely change, are their own download. pip install "tesseract-robotics-nanobind[support]" still works and warns that the extra does not exist. The dependency list moved from [project] dependencies to [tool.scikit-build.metadata.dependencies] requires, which scripts/support_metadata.py extends with the pin.
  • A non-finite jacobian raises NonFiniteJacobianError — in rc1, calcManipulability read a jacobian with a NaN or infinite entry as volume 0.0 and isNearSingularity as True: the SVD flags the input and its rank reads 0, so a blown-up FK chain looked like a singularity. Both now raise kinematics.NonFiniteJacobianError, a ValueError whose message names the first such entry. Neither function exists in 0.35, so code moving from 0.35 is not affected.

Changes

  • Sparse and multi-level SignedDistanceField — a field can keep one NanoVDB grid as stored and read it in place (SignedDistanceField(nvdb, band_clamp, scale), readSparseSignedDistanceFieldNVDB by grid name or index, getSignedDistanceFieldNVDBGridNames), or stack sparse fields of one surface by resolution, finest first (SignedDistanceField(levels)). Also bound: isSparse, getNVDB, getBandClamp, getLevels, getGradient, getDistanceAndGradient, and the SignedDistanceFieldInterpolation enum with set/getInterpolation and set/getGradientInterpolation. getDistances raises for a sparse field, which has no dense grid, and getDistance returns inf where it has no answer. tesseract is now built from upstream master e5c79c0c, which has tesseract#1390 and #1391 (and #1396, so the fork branch is no longer needed).
  • tesseract is built from 5dfd5ae2 — upstream master e5c79c0c plus tesseract#1408 (calcManipulabilityVolume), the PR's own branch on the jf--- fork, until it merges. build_identity.UPSTREAM_SOURCES and dependencies.rosinstall record it.
  • calcManipulabilityVolume and calcManipulabilityVolume_each — Yoshikawa manipulability without the six ellipsoids: bitwise calcManipulability(J).m.volume, from one SVD instead of three. calcManipulabilityVolume_each takes an (M, 6, n) stack, returns (M,) and releases the GIL; a non-finite jacobian's error names its index. calcManipulabilityVolume is tesseract's (tesseract#1408, carried); _each is the bindings' batch form. Every decomposition runs inside tesseract: a second SVD compiled into the binding module differed from m.volume in the last bits on linux-arm64 when environment was imported first. The kinematics API page gains a Manipulability section (definition, rank rule, errors), the user guide's singularity snippet uses these calls instead of det(J·Jᵀ), and kinematics_analysis_example shows both.
  • setCollisionObjectsTransform(ids, transforms) takes a (K, 4, 4) array — on DiscreteContactManager and ContinuousContactManager, K poses held in one float64 array (the layout of compose_each and link_transforms_batch) are set without an Isometry3d per object: at K = 80, 13-22 µs against 124-219 µs for (ids, [Isometry3d(m) for m in poses]) on the same machine. Each row is checked as Isometry3d(matrix) checks it before any object moves (NotRotationError names the row); len(ids) != K raises collision.TransformCountMismatchError, a ValueError. An id the manager does not hold is skipped, as by the list overload; a non-C-contiguous or non-float64 stack is converted first. The GIL is released while the poses are set. The rigid-transform rule and the stack helpers moved to src/bindings/transform_stack.h, shared by Isometry3d(matrix) and this overload.
  • ContactResultMap.to_arrays() and ContactResultVector.to_arrays() — every result of a contact test as numpy arrays in one call, returned as a collision.ContactArrays: row r is result r of flattenCopyResults() (the vector's own order), and each array equals the ContactResult field of the same name, bit for bit (distance, normal, nearest_points, nearest_points_local, transform, cc_time, cc_transform float64; type_id, shape_id, subshape_id int32, the C++ int; cc_type uint8, the enum's own type; single_contact_point bool), with link_ids as links (the distinct LinkIds in first-appearance order) plus an int32 link_index. Each array is an owned copy, valid after clear(). On 82 contacts against the ABB IRB2400 it takes 13-21 µs where a Python loop over five of the fields took 302-390 µs (over all of them, 1005-1334 µs), on a machine at load average 45-47.
  • The slots of a ContactResult are documented — ContactResult and its fields carry docstrings: entry k of every two-slot field describes link_ids[k], normal points from link_ids[0] towards link_ids[1], and which body is slot 0 is the contact manager's choice (neither alphabetical nor the map key's first()), so a body is found by id, never by slot. The collision user guide records what each manager was observed to do, and the API page's normal row no longer says "A to B".
  • kinematics.EmptyJacobianError — isNearSingularity on a matrix without rows or columns raises it; it is a ValueError, as before.
  • More impressive online planning example — make a more impressive online planning demo by dropping the collision cylinder around the arm, making gantry motions more expensive, and tweaking the person's path. Add a --sliders arg to move the person manually.
  • Every example runs as a test, or the test session fails naming it (#445) — a pytest plugin records with sys.monitoring which functions of tesseract_robotics.examples ran, merges the xdist workers' records, and fails a full session in which an example's main/run, or any function of a helper module, never ran. Discovery is automatic: there is no list to maintain. Tests that only called an example now assert on its result: trajectory validity for the low-level puzzle-piece, Descartes raster, task composer and low-level planning examples; the contact sweep (and its agreement across both collision ports); IK reaching its target; the scene graph edits. tesseract_collision_example, tesseract_kinematics_example, their low-level ports and pythonic_api_example gain a run() that returns these results, and main() calls it; the package attributes of the same names are now the run()s. scene_graph_c_api_example raises CommandRejectedError when the environment rejects a command, where it printed and went on, and inspects the edited scene graph instead of the first one; tesseract_planning_composer_c_api_example raises PlanningFailedError instead of returning False. lowlevel.example_support.trajectory_states lists a planned program's states, descending into raster segments. See "Every example is a test" in the developer guide.

Fixed

  • getState(ids, values) no longer pays for a failed overload on every call — nanobind tries a name's overloads in registration order, and the (joint_ids, joint_values) overload came after the {joint: value} map overload (and, on StateSolver, after the joint-vector overload). Each call first tried the id list as a map, which raises and clears an AttributeError (the dict caster calls .items()), and as a vector, which looks up __dlpack__ twice. With getStateByNamesAndValues gone in 0.36, getState(ids, values) is the only spelling, so code moving from 0.35 measured 6-14% slower per call. The (ids, values) overload now comes first in Environment.getState/setState and StateSolver.getState/setState/getJacobian; no argument converts to both, so every call reaches the same overload as before. Per call on the ABB IRB2400 at 200 000 calls (osx-arm64, load 4-40): Environment.getState 3.71 → 3.52 µs, StateSolver.getState 4.59 → 3.32 µs, StateSolver.getJacobian 3.56 → 2.57 µs, StateSolver.getState(names, values) with str names 8.14 → 5.60 µs.
  • The native build fetches kubazip by commit; a vcpkg rebuild no longer fails on its hash — kuba--/zip rewrote its history on 2026-11-20 and re-created tag v0.3.15 on the rewritten commit. The source tree is unchanged, but GitHub's archive of the tag changed bytes, so vcpkg 2026.10.16's kubazip port (pulled in by assimp) failed with "unexpected hash" on every build that did not restore it from the binary cache (microsoft/vcpkg#55200); macOS hit it first. A new overlay directory, .github/workflows/vcpkg_overlays_common, which native_stack.py passes on every platform and hashes into the vcpkg identity, carries the same port fetched as commit 5f680055 with that archive's SHA-512.
  • The macOS wheel's native libraries are built for macOS 12.0 again — trajopt builds osqp, OsqpEigen, piqp and qpOASES through ExternalProject_Add, which does not forward CMAKE_OSX_DEPLOYMENT_TARGET, so they were built for the build host's macOS, and the repair raised the wheel's tag with them: a local build on macOS 15.3 came out macosx_15_3_arm64, which pip matches on no Mac (from macOS 11 on it matches only macosx_<major>_0). native_stack.py now exports its OSX_DEPLOYMENT_TARGET as MACOSX_DEPLOYMENT_TARGET to colcon and to the bindings' build.
  • The macOS repair tags the wheel with the deployment target and refuses a library built for a newer macOS — repair_macos_wheel.py raised the tag to the highest minimum macOS in the bundled closure, which hid the defect above. It now writes native_stack.OSX_DEPLOYMENT_TARGET into the tag and raises DeploymentTargetExceededError, naming each bundled image and its minimum macOS, when one is above it; a target pip cannot match (12.3: from macOS 11 on pip matches only macosx_<major>_0) raises UninstallableTagError. Homebrew's libomp (15.0) is such a library: a wheel that bundles it is refused.
  • The macOS repair writes the same bytes on every platform; the Windows wheel job passes again — repair_macos_wheel.py rewrote WHEEL, RECORD and the packaged YAML with Path.write_text, which on Windows writes each newline as \r\n and encodes in the locale codepage, so test_anchored_repair_names_the_wheel_for_the_deployment_target failed on native-win-x64. WHEEL and the YAML are now edited in place as UTF-8 with their line endings kept, and RECORD is written with \n line endings, as the wheel package writes it. RECORD's hashes were never wrong: they are taken from the bytes on disk after the rewrite.
  • The macOS wheel bundles conda-forge's libomp (macOS 11.0), as the local build does — the workflow's macOS leg linked and bundled Homebrew's libomp, built for macOS 15.0, which the repair above refuses. It now installs the locked default pixi env (setup-pixi, locked: true) and passes that env's $CONDA_PREFIX as the libomp prefix, the prefix the local pixi tasks pass, so CI bundles the llvm-openmp that pixi.lock pins. brew install no longer installs libomp. The native-cache key records that package (llvm-openmp <version> <build>, read from the env's conda-meta) where it recorded Homebrew's libomp; a prefix without exactly one record raises LibompRecordError.
  • The wheels build again: the tesseract pin is reachable — tesseract#1408 was rebased, so 5dfd5ae2 was on no branch of jf---/tesseract and vcs import could not check it out on any platform. Branch nanobind-pin/5dfd5ae2 on the fork keeps it reachable; the build is unchanged.
  • Docs images no longer turn CI red (#446) — docs-figures --check and test_figures_reproducible.py fail only on structure (a figure missing from the lock or the commit, an SVG that is not well-formed or draws nothing); an edited figure or script, an upstream bump or different bytes are reported as stale. The Docs workflow builds a page without a demo player or poster that the lock or the demo-assets release lacks, with a ::warning:: naming the file, instead of failing on a KeyError; a download whose bytes differ from the lock still fails.
  • calcManipulability on a jacobian without columns raises EmptyJacobianError — np.zeros((6, 0)) segfaulted.
  • Every member gives one quaternion the same rotation, bit for bit (#463) — in rc1, Isometry3d(q), Isometry3d(translation, q), Isometry3d * q, rotate, prerotate and AngleAxisd(q) divided every quaternion by its norm, while toRotationMatrix, to_rpy, eulerAngles and q * v converted it as given. For a quaternion unit only to rounding (from Quaterniond(R), squared norm 1 - 2^-53) the division re-rounds its coefficients, and Isometry3d(q).linear differed from q.toRotationMatrix() in the last bit; 0.35 gave both the same. All of them now convert through one rule: q as given when |q.squaredNorm() - 1| <= 6·eps, q / |q| otherwise. 6·eps bounds the squared-norm defect of q / |q| as float64 computes it, so the rule is idempotent: a quaternion as unit as division can make it is never divided again. A unit quaternion converts as in 0.35 again; a non-unit one is normalized as rc1 documents, now also by toRotationMatrix, to_rpy, eulerAngles and q * v, which gave Eigen's scaled, non-rotation result. Those four raise DegenerateRotationError for a zero or non-finite quaternion, as the constructors do.

0.36.0.0rc1 - 2026-11-11 — pre-release on upstream master plus our open PRs

Pre-release: pip install --pre tesseract-robotics-nanobind. The wheels build tesseract, trajopt and tesseract_planning from nanobind-0.36 branches on the jf--- forks, each upstream master plus the open upstream PRs we filed, so the release does not wait on upstream review. tesseract_robotics.build_identity.UPSTREAM_SOURCES records the SHAs and PRs, and dependencies.rosinstall pins them:

repository master carried PRs fork SHA
tesseract a9c22066 #1396 4cf644d7
tesseract_planning a6483823 #789, #792, #794 4e27d94b
trajopt 963baf7d #628, #629 98b85d55

The tag regex and the wheels workflow's tag filter accept an rcN suffix. docs/changes-0.36.md has the 0.35 → 0.36 migration, with a before/after example per change (#141, #161).

  • isValidState bound — isValidState(joint_group, base_link, tcp_frame, joint_values, limits) is true when the values are within limits and the arm's configuration, read with sign correction (-1, 1), is FUT or NUT. It needs tesseract_planning#792, which makes isWithinLimits<FloatType> deduce; before it the double instance did not compile (#333).

Breaking changes

  • Maps keyed by a link or joint are keyed by name — calcFwdKin, SceneState.joints / floating_joints / link_transforms / joint_transforms, getLinkTransforms(ids, values), getCurrentFloatingJointValues, getFloatingJointValues, the joint-limit commands' getLimits, ContactManagerConfig.modify_object_enabled, KinematicsInformation.group_states / group_tcps, CalibrationInfo.joints and the keys of SceneGraph.getAdjacencyMap return dict[str, V], so poses["tool0"] is exactly typed (rc1: dict[LinkId, V], poses[LinkId("tool0")]). Parameters still take names or ids; LinkIdPair-keyed maps are unchanged, since a pair is unordered and a tuple key is not.
  • Online planning examples: final_rows, style_for_viewer, update_human_position, VIEWER_STEP_S and the HUMAN_* constants are removed — the scene lives in online_planning_scene; recordings use the examples' recording_rows.
  • PyPI wheels are built without conda, the tesseract_python way — .github/workflows/wheels.yml builds the C++ stack from source (dependencies.rosinstall: the nanobind-0.36 fork commits above) with colcon against vcpkg dependencies, and auditwheel, delvewheel or the batched macOS repair bundles it. The plugin factories are linked into the collision, kinematics and task composer modules and registered through their boost_plugin_loader anchors, so the wheel loads its bundled copies by path. wheels-{linux,macos,windows}.yml, scripts/build_{linux,macos}_wheel.sh and the build-wheel pixi task are removed, and tesseract_robotics no longer sets TESSERACT_*_PLUGIN_DIRECTORIES, reads TESSERACT_PLUGIN_PATH or rewrites the task composer YAML. What changes for users:
  • Linux wheels are manylinux_2_39 (Ubuntu 24.04+, Debian 13+; Ubuntu 22.04 is no longer supported), up from manylinux_2_35; the old floor was nominal, since the bundled libraries already needed a gcc-13 era libstdc++.
  • macOS wheels ship for x86_64 as well as arm64, with a macOS 15.0 minimum (macosx_15_0), imposed by the bundled Homebrew libomp.
  • macOS OpenMP users resolve @rpath/libomp.dylib from the Python environment’s lib/ first, then the bundled library. CI checks both import orders in plain and pixi consumers and exercises Descartes (#136).
  • Importing tesseract_robotics no longer sets environment variables; the robot models are a separate wheel — the import used to write TESSERACT_SUPPORT_DIR, TESSERACT_RESOURCE_PATH, TESSERACT_TASK_COMPOSER_CONFIG_FILE and TESSERACT_TASK_COMPOSER_DIR into os.environ (and on Windows prepend to PATH), so every bare GeneralResourceLocator() resolved package://tesseract/support/.... It now changes nothing, and no API adds resource search paths on its own. tesseract's robot models and meshes moved out of the bindings wheel into tesseract-robotics-nanobind-support, installed by the [support] extra; the bindings wheel keeps the task composer config. Migrating:
before after
pip install tesseract-robotics-nanobind (models included) pip install "tesseract-robotics-nanobind[support]"
GeneralResourceLocator() resolving package://tesseract/support/... GeneralResourceLocator(paths=[tesseract_robotics.get_tesseract_resource_path()]), or set TESSERACT_RESOURCE_PATH yourself
Robot.from_tesseract_support("abb_irb2400") Robot.from_tesseract_support("abb_irb2400", locator) with that locator
os.environ["TESSERACT_SUPPORT_DIR"] tesseract_robotics.get_tesseract_support_path()
os.environ["TESSERACT_TASK_COMPOSER_CONFIG_FILE"] tesseract_robotics.get_task_composer_config_path() (still honours the variable when you set it)
tesseract_robotics.ensure_configured() removed; nothing to configure
TaskComposer.from_config() reading TESSERACT_TASK_COMPOSER_DIR reads get_task_composer_config_path() only

get_tesseract_resource_path() and get_tesseract_support_path() raise SupportDataNotFoundError when the support wheel is not installed; the only source is the tesseract-robotics-nanobind-support distribution, with no fallback to an environment's share/. planning.mesh_from_file and convex_mesh_from_file take a locator for package:// URLs. pyyaml, which tesseract_robotics.planning imports, is now a declared dependency. - Python 3.12 is the minimum; Rhino 8 loses wheels — requires-python rises from >=3.9 to >=3.12. One cp312-abi3 wheel per platform now covers 3.12, 3.13 and 3.14, including Rhino 9 (CPython 3.13). Rhino 8 (CPython 3.9) and Python 3.10–3.11 stay on 0.35.0.8, the last release with wheels for them (#369; docs/breaking-changes.md). - numpy 2.0 and scipy 1.17.1 are the minimum — numpy>=1.21.0 and scipy>=1.7.0 were never tested. The scipy floor is the oldest scipy CI runs; numpy 1.x users stay on 0.35.0.8. importlib-resources is no longer a dependency: the viewer uses stdlib importlib.resources (#369). - planning.program.Target and emitters.core.events.Event are type aliases — isinstance(x, Target) and typing.get_args(Target) raise or return nothing; use Target.__value__ or test the member classes (#369; docs/breaking-changes.md). - tesseract_robotics.viewer is now backed by viser; the Three.js/aiohttp viewer is removed (#367) — viser, trimesh and pillow replace aiohttp. The viewer serves from construction and viewer.url is its address. See docs/user-guide/viewer.md.

before after
TesseractViewer(server_address=("127.0.0.1", 8000)) TesseractViewer(host="127.0.0.1", port=8000); a taken port raises ViewerPortInUseError
update_environment(env, origin_offset), update_environment(env, trajectory=) update_environment(env), then update_trajectory
update_trajectory_list(names, rows) update_trajectory(Trajectory.from_rows(names, rows))
start_serve_background() removed; serving starts in the constructor
add_{axes,arrow,box,sphere,cylinder,capsule,lines}_marker, clear_all_markers, clear_markers_by_tags, clear_markers_by_name, send_update_markers viewer.server.scene
save, save_scene_gltf, save_scene_glb removed
ssl_context, examples/shapes_viewer_ssl_webxr_headset.py removed; viser has no TLS or WebXR

Calls in the wrong order raise instead of passing silently: update_joint_positions and update_trajectory before an environment (NoEnvironmentError), show_time without a trajectory (NoTrajectoryError). - Example main()s return exit codes — 0 on success, 1 when planning failed. They returned True (console scripts exited 1 on success) or a success flag (exited 0 on failure), so tesseract_*_example commands now report failure correctly. tesseract_reeds_shepp_example targets a new main. - Links and joints are addressed by id, not by name — upstream replaced link and joint names with typed ids derived from the name, and the bindings follow it: LinkId, JointId and LinkIdPair in tesseract_common. Getters are renamed and return ids: get*Names() → get*Ids(), getRootLinkName() → getRootLinkId(), ContactResult.link_names → link_ids, Joint.parent_link_name / child_link_name → parent_link_id / child_link_id, JointState.joint_names → joint_ids, waypoint getNames() / setNames() → getJointIds() / setJointIds(); the full table is in docs/changes-0.36.md. A str converts to an id wherever one is taken, and an id equals and hashes like its name, so state.link_transforms["tool0"] still finds an id-keyed entry. What breaks: code that treats a returned id as a str ("link_" + lid, json.dumps, format specs need .name()), passes a LinkId where a JointId is taken (TypeError; the two do not convert), calls acm.isCollisionAllowed("a", "b") or getCollisionCoeff("a", "b") with two names (pass one pair: (("a", "b"))), or uses the joint_names= keyword on setStateByMap / getStateByMap and their siblings (now joint_ids=). A LinkIdPair is unordered and never equals a tuple; index a pair-keyed dict such as getAllAllowedCollisions() by LinkIdPair("a", "b"). Id-typed data members read as copies, as the str fields they replace did. The tesseract_robotics.planning API and the viewer keep str at their boundary (#141). - console_bridge logging API removed; spdlog API added — upstream logs through spdlog (tesseract#1367), so setLogLevel, getLogLevel, log, useOutputHandler, restorePreviousOutputHandler, OutputHandler and the CONSOLE_BRIDGE_LOG_* constants still imported but no longer changed tesseract's output. They are removed, and LogLevel is now spdlog's level enum (trace, debug, info, warn, err, critical, off). The replacement mirrors upstream: getLogger(name="tesseract") returns a Logger with level() / set_level() / should_log(), isLogLevelEnabled(level), and addLogRecordHandler(fn) / removeLogRecordHandler(id) route each LogRecord (level, message, logger and component name, attributes, timestamp, source location) to a Python callable on whichever thread logs. A handler that raises is reported through sys.unraisablehook instead of being swallowed, and handlers still registered at exit are removed before the interpreter finalizes Record handlers run synchronously on the thread that logs, with no tesseract lock held. descartes_light still logs through console_bridge, to stderr and not routed to the handlers, until swri-robotics/descartes_light#130 (#141). - TaskComposerKeys → TaskComposerPortMap — upstream tesseract_planning#760 maps node ports to storage keys through TaskComposerPortMap: getInputKeys() / getOutputKeys() → getInputPortMappings() / getOutputPortMappings(), keys.get(...) → ports.single(...) (or multiple / at), has → contains, setInputKeys / setOutputKeys → setPortMappings(inputs, outputs), getPorts() → getPortContract() (a copy; None for a graph or pipeline), validatePorts() → getPortContract().validateOrThrow(inputs, outputs, name), setOverrideInputKeys / setOverrideOutputKeys → setOverrideInputPortMappings / setOverrideOutputPortMappings, TaskComposerNodeInfo.input_keys / output_keys → input_port_mappings / output_port_mappings. A graph built in Python needs setPortMappings before an override or a run: 0.36 rejects an override of a port its boundary does not declare, and a graph whose boundary does not supply its children's inputs is invalid (#141). - State solver: no {name: value} getJacobian — upstream 0.36 has no map overload; pass the values in getJointIds() order, or getJacobian(joint_ids, joint_values, link_id). The state-solver getters are on ids (getJointIds, getActiveLinkIds, isActiveLinkId, hasLinkId, …) and the link_name= keyword is link_id= (#141). - makeOrderedLinkPair and UnorderedLinkPairError removed — a LinkIdPair is unordered by construction, so there is nothing to order and no unordered key to reject; LinkIdPair("b", "a") == LinkIdPair("a", "b"), and orderedNameView() returns the names sorted. Two-name readers take one pair: isCollisionAllowed, CollisionMarginPairData.getCollisionMargin, CollisionCoeffData.getCollisionCoeff (#141). - Collision evaluators lost getGradient / calcGradientData — upstream 0.36 moved contact gradients to trajopt_common::getGradient; see the trajopt_ifopt.getGradient entry below (#141). - Unordered results — SceneGraph.getJointChildrenIds(list), ContactResultMap iteration and getContainer(), and getPairsWithZeroCoeff() come from upstream unordered containers; compare them as sets or sort them (#141). - SDFMesh → SignedDistanceField — SDFMesh is gone upstream; see the SignedDistanceField entry below (#129). - Constraint violations carry raw and weighted forms — evaluateConvexConstraintViolations(), getExactConstraintViolations() and SQPResults.*_constraint_violations return a ConstraintViolations with raw (unweighted, compared against cnt_tolerance) and weighted (charged by the merit) arrays instead of one array (#141). - CollisionCoeffData.setPairCollisionCoeff / getPairCollisionCoeff removed — copies of setCollisionCoeff / getCollisionCoeff under names C++ does not have. Call the C++ names (#298). - CollisionCoeffData, TrajOptCollisionConfig and SQPParameters compare by value and are unhashable — == compared identity; hash(), set members and dict keys now raise TypeError (#261). - The collision constraints reject a Var outside a variable set — DiscreteCollisionConstraint, DiscreteCollisionNumericalConstraint, ContinuousCollisionConstraint and the new collision classes raise VarNotInVariableSetError (a ValueError) at construction when the Var is not in a NodesVariables. trajopt reads the set's hash through the Var's parent pointers unchecked, so such a constraint dereferenced null on its first update(). A Var from Node.addVar qualifies once its Node is handed to NodesVariables (#297). - OSQPEigenSolver's update methods check sizes — updateGradient, updateLowerBound, updateUpperBound and updateBounds raise QPSizeError (a ValueError) on a vector whose length is not the init() size; trajopt indexed past it (#283). - Command-language types compare by value and are unhashable — the 16 waypoint, instruction and Poly types bind __eq__/__ne__ from the C++ operators and set __hash__ = None; hash(), set members and dict keys raise TypeError. MoveInstruction equality includes both UUIDs (#261; docs/breaking-changes.md has the migration). - Time-parameterization profiles compare by value and are unhashable — TOTGCompositeProfile, ISPCompositeProfile, ISPMoveProfile and ConstantTCPSpeedCompositeProfile bind __eq__/__ne__ from the C++ operator== (identity before) and set __hash__ = None, as #169 did for collision, common and environment: hash(), set members and dict keys raise TypeError (#261). - The seven simple-planner move profiles compare by value and are unhashable — SimplePlannerFixedSize{,Assign,AssignNoIK}MoveProfile and SimplePlannerLVS{,NoIK,Assign,AssignNoIK}MoveProfile bind the C++ operator==; hash(), set members and dict keys raise TypeError (#261).

  • OMPLSolverConfig.getNumPlanners() removed; planners is readable — solver_config.planners binds the configurator list, so Python sees which planners a profile holds, not only how many. The list is copied on access; its configurators are shared with the config, so cfg.planners[0].range = 0.5 edits the config. To change which planners it holds, assign a new list, or use addPlanner / clearPlanners, which stay as the in-place mutators (#302).
before after
cfg.getNumPlanners() len(cfg.planners)
  • OMPL, TrajOpt and task-composer planning value types compare by value and are unhashable — OMPLSolverConfig, OMPLRealVectorMoveProfile, TrajOptCartesianWaypointConfig, TrajOptJointWaypointConfig, TrajOptDefaultMoveProfile, TrajOptDefaultCompositeProfile, TrajOptOSQPSolverProfile, BasicTrustRegionSQPParameters and the seven tesseract_task_composer_planning profiles bind the C++ operator==; hash(), set members and dict keys raise TypeError. OMPLSolverConfig compares planners by count only, as upstream (#261).
  • create_ompl_planner_configurators rejects a keyword that fits none of the requested planners — it accepts every OMPLPlannerType name and sets each keyword on the configurators that have that field; a keyword no requested configurator has raises ValueError instead of being ignored (#301).
  • TrajOpt-Ifopt and Descartes profiles and waypoint configs compare by value and are unhashable — TrajOptIfoptCartesianWaypointConfig, TrajOptIfoptJointWaypointConfig, TrajOptIfoptDefaultMoveProfile, TrajOptIfoptDefaultCompositeProfile, TrajOptIfoptOSQPSolverProfile, DescartesDefaultMoveProfileD and DescartesLadderGraphSolverProfileD bind __eq__/__ne__ from the C++ operator== and set __hash__ = None; hash(), set members and dict keys raise TypeError (#261).
  • TaskComposerPluginFactory: a str is YAML text, a pathlib.Path a file — the factory now binds both C++ constructors and loadConfig overloads like KinematicsPluginFactory; a path passed as str raises ValueError. planning.TaskComposer, the tests and the docs pass a Path (#337).
  • Task-composer compatibility helpers removed — createTaskComposerPluginFactory, createTaskComposerDataStorage, TaskComposerKeys.addKeys, TaskComposerDataStorage.getAllData, TaskComposerNodeInfoContainer.getAllInfos / getAbortingNodeInfo, the container overloads of getDotgraph / saveDotgraph and the package __all__; each has a C++-named replacement (#313, #314, #336, #338).
  • TaskComposerNode.saveDotgraph raises OSError — it returned False when the file could not be written and now raises OSError (FileNotFoundError for a missing directory) and returns None, as saveConfig does; it takes a str or an os.PathLike (#316).
  • TaskComposerConfigError — a str config that does not load in TaskComposerPluginFactory(str, locator), its loadConfig and TaskComposerServer.loadConfig raises TaskComposerConfigError, a ValueError subclass, instead of a bare ValueError; so does YAML text without a top-level task_composer_plugins mapping (empty, ~, a list, an unrelated mapping), which upstream loaded silently as an empty config (#337).
  • Task-composer value types compare by value — AnyPoly, TaskComposerKeys, TaskComposerDataStorage, TaskComposerNodeInfo, TaskComposerNodeInfoContainer, TaskComposerContext, TaskComposerNodePorts, TaskComposerLog bind == and are unhashable (#261).

  • SWIG-era MoveInstructionType_* constants removed — tesseract_command_language exported MoveInstructionType_LINEAR, MoveInstructionType_FREESPACE and MoveInstructionType_CIRCULAR, copies of the enum members kept from the SWIG bindings; C++ has none of them. Importing one raises ImportError, reading one as a module attribute raises AttributeError; the enum members are the same objects. The package's hand-kept __all__ is gone too, so from tesseract_robotics.command_language import * exports every public name of the extension (toJointTrajectory, moveFilter, …), not a stale subset. The module joins the #176 no-alias guard (#275).

before after
MoveInstructionType_LINEAR (also _FREESPACE, _CIRCULAR) MoveInstructionType.LINEAR (.FREESPACE, .CIRCULAR)
  • assign*Waypoint and ProfileDictionary_addProfile removed — MoveInstruction and MoveInstructionPoly lose assignCartesianWaypoint, assignJointWaypoint and assignStateWaypoint, SWIG-era copies of setWaypoint (C++ 0.33 removed them); tesseract_command_language.ProfileDictionary_addProfile(d, ns, name, p) is gone, since d.addProfile(ns, name, p) takes every module's profiles. Nothing in the repository called them (#276).

  • SWIG-era Poly helpers and appendMoveInstruction removed — the 14 module functions CartesianWaypointPoly_wrap_CartesianWaypoint, JointWaypointPoly_wrap_JointWaypoint, StateWaypointPoly_wrap_StateWaypoint, MoveInstructionPoly_wrap_MoveInstruction, InstructionPoly_as_* (7) and WaypointPoly_as_* (3), and CompositeInstruction.appendMoveInstruction, duplicated a constructor or method; C++ has none of them. Every in-repo caller moved to the native form. wp.as…Waypoint() returns a reference into the waypoint where WaypointPoly_as_* returned a copy: edits through it reach the program; copy.copy(wp.as…Waypoint()) is the copy (#328).

before after
CartesianWaypointPoly_wrap_CartesianWaypoint(wp) (also Joint…, State…) CartesianWaypointPoly(wp)
MoveInstructionPoly_wrap_MoveInstruction(mi) MoveInstructionPoly(mi)
InstructionPoly_as_MoveInstructionPoly(ip) ip.asMoveInstruction()
InstructionPoly_as_CompositeInstruction(ip) (also Wait, Timer, SetAnalog, SetDigital, SetTool) ip.asCompositeInstruction() (asWaitInstruction(), …)
WaypointPoly_as_CartesianWaypointPoly(wp) (also Joint…, State…) wp.asCartesianWaypoint() (a reference)
program.appendMoveInstruction(mi) program.push_back(mi)
  • Time-parameterization profiles bound under their C++ names — TOTGCompositeProfile, ISPCompositeProfile, ISPMoveProfile and ConstantTCPSpeedCompositeProfile are now TimeOptimalTrajectoryGenerationCompositeProfile, IterativeSplineParameterizationCompositeProfile, IterativeSplineParameterizationMoveProfile and ConstantTCPSpeedParameterizationCompositeProfile, as every other planner profile is (#187). No alias: the old names raise ImportError. The package's __all__ is gone; import * exports every public name of the extension (#329).
before after
TOTGCompositeProfile TimeOptimalTrajectoryGenerationCompositeProfile
ISPCompositeProfile IterativeSplineParameterizationCompositeProfile
ISPMoveProfile IterativeSplineParameterizationMoveProfile
ConstantTCPSpeedCompositeProfile ConstantTCPSpeedParameterizationCompositeProfile
  • Six trajopt_sqp enumerators renamed to their C++ names — every SQPStatus and QPSolverStatus member is now the UPPER_SNAKE form of its C++ kCamelCase name. This reverses the 0.34 "Python names preserved" choice for the six whose kept name differed from C++ (one was a typo). No aliases: the old names raise AttributeError, and code comparing status.name against an old string now silently fails to match — search for those strings (#330).
before after
SQPStatus.NLP_CONVERGED SQPStatus.CONVERGED
SQPStatus.OPT_TIME_LIMIT SQPStatus.TIME_LIMIT
SQPStatus.QP_SOLVER_ERROR SQPStatus.QP_SOLVE_FAILED
SQPStatus.CALLBACK_STOPPED SQPStatus.STOPPED_BY_CALLBACK
QPSolverStatus.UNITIALIZED QPSolverStatus.UNINITIALIZED
QPSolverStatus.QP_ERROR QPSolverStatus.FAILED
  • Planner-module compatibility names removed: ProfileDictionary_add*, *_as_ProfileConstPtr, cast_Descartes*, the 0.28 …PlanProfile names, trajopt's 0.28 re-exports and the packages' __all__ — ProfileDictionary.addProfile(ns, name, profile) takes a profile from every planner module, including a Python subclass of a trampolined profile, so the 15 helper functions are gone (#334). The eight …PlanProfile aliases of the 0.33 …MoveProfile classes are gone, and so are TrajOptCollisionConfig / CollisionEvaluatorType in tesseract_motion_planners_trajopt. tesseract_motion_planners_trajopt_ifopt keeps its config re-exports (TrajOptCollisionConfig, CollisionEvaluatorType, SQPParameters). The six tesseract_motion_planners* packages lose their __all__; import * now exports every public name, e.g. OMPLRealVectorMoveProfile and RNG_setSeed from the OMPL package, which its old list left out (#335).
before after
ProfileDictionary_addTrajOptMoveProfile(pd, ns, name, p) (all 10 ProfileDictionary_add…) pd.addProfile(ns, name, p)
OMPLMoveProfile_as_ProfileConstPtr(p), cast_DescartesMoveProfileD(p) (all 5 casts) p
TrajOptDefaultPlanProfile (all 8 …PlanProfile names) TrajOptDefaultMoveProfile
from …tesseract_motion_planners_trajopt import TrajOptCollisionConfig from tesseract_robotics.trajopt_ifopt import TrajOptCollisionConfig
from …tesseract_motion_planners_trajopt import CollisionEvaluatorType from tesseract_robotics.collision import CollisionEvaluatorType
  • create_time_optimal_parameterization and create_iterative_spline_parameterization take no arguments — path_tolerance, min_angle_change and add_points were accepted and silently ignored since 0.33 moved them into the composite profiles. Passing one now raises TypeError; set the field on the profile instead.
before after
create_time_optimal_parameterization(path_tolerance=0.05, min_angle_change=0.01) create_time_optimal_parameterization(), and TimeOptimalTrajectoryGenerationCompositeProfile().path_tolerance = 0.05 (.min_angle_change)
create_iterative_spline_parameterization(add_points=False) create_iterative_spline_parameterization(), and IterativeSplineParameterizationCompositeProfile().add_points = False
  • tesseract_robotics.ompl_base removed — the module, its hand-written stub and reeds_shepp_example.py / tesseract_reeds_shepp_example. It wrapped five OMPL headers directly, and nothing in the package used it; OMPL stays a dependency of the OMPL planner, which loads it in C++. Use OMPL's own Python bindings for State, RealVectorBounds, SE2StateSpace, ReedsSheppStateSpace or DubinsStateSpace (#258).
  • The planning API no longer picks a TCP or a working frame — Robot.get_manipulator_info and TaskComposer.plan guessed the TCP as the last entry of getActiveLinkNames() (an order that holds for a serial chain, not a tree), MotionProgram and get_manipulator_info defaulted working_frame to the literal "base_link", and get_manipulator_info cached the guess and handed every caller the same mutable ManipulatorInfo. Robot.fk / Robot.ik guessed tip_link the same way. tcp_frame and working_frame are now required in MotionProgram and get_manipulator_info, tip_link in fk and ik; a missing one raises TypeError at the call. Both take a keyword-only tcp_offset (str | Isometry3d, default identity) that goes to ManipulatorInfo.tcp_offset unchanged, so a named SRDF TCP reaches the planner, which resolves it with Environment.findTCPOffset. get_manipulator_info builds a new object per call; to_composite_instruction loses its tcp_frame override, the program's frames are the only source (#30, #133).
before after
MotionProgram("manipulator") MotionProgram("manipulator", tcp_frame="tool0", working_frame="base_link")
MotionProgram("manipulator", tcp_frame="tool0") MotionProgram("manipulator", tcp_frame="tool0", working_frame="base_link")
robot.get_manipulator_info("manipulator") robot.get_manipulator_info("manipulator", "tool0", "base_link")
robot.fk("manipulator", q) robot.fk("manipulator", q, "tool0")
robot.ik("manipulator", pose, seed=q) (also tip_link= after seed) robot.ik("manipulator", pose, "tool0", seed=q)
program.to_composite_instruction(joint_names, "tool0") program.to_composite_instruction(joint_names)
ManipulatorInfo with a TCP offset, built by hand MotionProgram(..., tcp_offset="laser") or tcp_offset=Isometry3d(...)

For the support robots (abb_irb2400, lbr_iiwa_14_r820) the old guesses were "tool0" and "base_link": passing those reproduces the old behaviour exactly.

  • std::filesystem::path is pathlib.Path; Environment.init(str, …) always means content — tesseract_common.FilesystemPath was a str subclass, so Environment.init could not tell a path from URDF content: init(str, str, locator) treated both strings as paths (the opposite of the C++ std::string overload), init(str, locator) guessed from a leading <, and the Python-only initFromUrdf / initFromUrdfSrdf existed to work around the guess. std::filesystem::path now converts with nanobind's caster (str | os.PathLike in, pathlib.Path out), and Environment.init binds the four native overloads: a str is URDF/SRDF content, a pathlib.Path (any os.PathLike) is a file. Where a path overload sits beside a content overload (Environment.init ×2, the ContactManagersPluginFactory and KinematicsPluginFactory config constructors), the path parameter accepts os.PathLike only, so a str never reaches it and a mixed init(content, Path, locator) raises TypeError. Removed: FilesystemPath, _FilesystemPath, TransformMap (a plain dict converts) and Environment.initFromUrdf / initFromUrdfSrdf. A path left as str makes init return False; it does not raise (#165).
before after
env.init(FilesystemPath(u), FilesystemPath(s), loc) env.init(Path(u), Path(s), loc)
env.init(path_str, loc) (path) env.init(Path(path_str), loc)
env.initFromUrdf(xml, loc) env.init(xml, loc)
env.initFromUrdfSrdf(u_xml, s_xml, loc) env.init(u_xml, s_xml, loc)
KinematicsPluginFactory(_FilesystemPath(p), loc) (also ContactManagersPluginFactory) KinematicsPluginFactory(Path(p), loc)
TaskComposerPluginFactory(FilesystemPath(p), loc) TaskComposerPluginFactory(str(p), loc)
TransformMap() {}

TaskComposerPluginFactory still takes its config path as str: tesseract_task_composer is outside the audited modules, so its native path/content pair is not bound yet.

  • tesseract_environment and tesseract_command_language no longer re-export task-composer functions — tesseract_environment/__init__.py imported AnyPoly_wrap_EnvironmentConst from tesseract_task_composer inside try: … except ImportError: pass, and tesseract_command_language/__init__.py did the same for AnyPoly_wrap_CompositeInstruction, AnyPoly_wrap_ProfileDictionary and AnyPoly_as_CompositeInstruction, behind a _HAS_TASK_COMPOSER flag. A broken task-composer extension (a missing dylib, say) made the names vanish silently, and from tesseract_robotics.environment import * then raised AttributeError for a name in __all__, far from the cause. Both imports also loaded the task composer as a side effect. The re-exports, their __all__ entries and _HAS_TASK_COMPOSER are removed; import the functions from tesseract_task_composer, where they are defined. Importing either package no longer imports tesseract_task_composer (#192).
before after
from tesseract_robotics.environment import AnyPoly_wrap_EnvironmentConst from tesseract_robotics.task_composer import AnyPoly_wrap_EnvironmentConst
from tesseract_robotics.command_language import AnyPoly_wrap_CompositeInstruction (also AnyPoly_wrap_ProfileDictionary, AnyPoly_as_CompositeInstruction) from tesseract_robotics.task_composer import AnyPoly_wrap_CompositeInstruction (…)
tesseract_command_language._HAS_TASK_COMPOSER removed: the task composer is a hard dependency
  • SWIG-era enum constants removed — tesseract_collision, tesseract_environment and tesseract_common exported a module constant for each value of four bound enums, kept from the SWIG bindings: ContactTestType_FIRST / _CLOSEST / _ALL / _LIMITED, Events_COMMAND_APPLIED / _SCENE_STATE_CHANGED, ModifyAllowedCollisionsType_ADD / _REMOVE / _REPLACE and the module-level CONSOLE_BRIDGE_LOG_DEBUG / _INFO / _WARN / _ERROR / _NONE. C++ has no such constants (the CONSOLE_BRIDGE_LOG_* names are LogLevel enumerators, not module names), and each enum is bound as a class. All 14 constants and their __all__ entries are gone: importing one raises ImportError, reading one as a module attribute raises AttributeError. Use the enum member; the values are the same objects (#176).
before after
ContactTestType_ALL (also _FIRST, _CLOSEST, _LIMITED) ContactTestType.ALL (.FIRST, .CLOSEST, .LIMITED)
Events_COMMAND_APPLIED, Events_SCENE_STATE_CHANGED Events.COMMAND_APPLIED, Events.SCENE_STATE_CHANGED
ModifyAllowedCollisionsType_ADD (also _REMOVE, _REPLACE) ModifyAllowedCollisionsType.ADD (.REMOVE, .REPLACE)
CONSOLE_BRIDGE_LOG_DEBUG (also _INFO, _WARN, _ERROR, _NONE) LogLevel.CONSOLE_BRIDGE_LOG_DEBUG (…_INFO, …_WARN, …_ERROR, …_NONE)
  • Pre-0.33 collision-margin aliases removed — eight Python names that forwarded to members tesseract 0.33 renamed, each bound next to the native member: ContactManagerConfig.margin_data_override_type, DiscreteContactManager / ContinuousContactManager .setDefaultCollisionMarginData and .setPairCollisionMarginData, tesseract_common.CollisionMarginOverrideType, and CollisionMarginData.getPairCollisionMargin / .setPairCollisionMargin. Using one raises AttributeError (ImportError for from tesseract_robotics.common import CollisionMarginOverrideType). The ContactManagerConfig example in the collision API page used a config.margin_data member that never existed; it now sets default_margin, pair_margin_data and pair_margin_override_type (#177).
before after
config.margin_data_override_type config.pair_margin_override_type
manager.setDefaultCollisionMarginData(m) manager.setDefaultCollisionMargin(m)
manager.setPairCollisionMarginData(a, b, m) manager.setCollisionMarginPair(a, b, m)
CollisionMarginOverrideType CollisionMarginPairOverrideType
margins.getPairCollisionMargin(a, b) margins.getCollisionMargin(a, b)
margins.setPairCollisionMargin(a, b, m) margins.setCollisionMargin(a, b, m)
  • createTaskComposerNode / createTaskComposerExecutor raise TaskComposerPluginError instead of returning None — upstream returns null for an unknown name, a plugin symbol that fails to load and a plugin factory that throws, with only a console_bridge warning on stderr, and the binding passed that on as None although the stub promised a TaskComposerNode / TaskComposerExecutor. Callers got an AttributeError later, far from the cause, and TaskComposer.warmup / get_available_pipelines counted an unknown or unbuildable name as loaded, since their except never fired. Both methods now raise the new TaskComposerPluginError (a RuntimeError): for a name that is not configured, the message lists the configured names; for a configured plugin that cannot load or build, it points at the warning. TaskComposer.warmup and get_available_pipelines catch it, and TaskComposer.plan returns its message in the failed PlanningResult (#203).
before after
node = factory.createTaskComposerNode(name)
if node is None: …
try: node = factory.createTaskComposerNode(name)
except TaskComposerPluginError: …
executor = factory.createTaskComposerExecutor(name)
if executor is None: …
try: executor = factory.createTaskComposerExecutor(name)
except TaskComposerPluginError: …
  • Value types compare by value and are unhashable — the collision, common and environment classes that declare operator== were bound without it, so == compared identity: two equal objects compared unequal and nothing raised. 37 classes now bind __eq__/__ne__ and set __hash__ = None: ContactResult, ContactResultMap, ContactRequest, ContactManagerConfig, CollisionCheckConfig; AllowedCollisionMatrix, BytesResource, CollisionMarginData, CollisionMarginPairData, GeneralResourceLocator, JointState, KinematicLimits, KinematicsPluginInfo, ManipulatorInfo, PluginInfo, PluginInfoContainer, SimpleLocatedResource; Environment, Command and all 18 remaining commands. hash() on them, and using one as a set member or dict key, now raises TypeError. Equality is upstream's: floating-point fields compare within the C++ tolerance (JointState positions with isApprox(1e-5), for example), ContactRequest.is_valid compares the validator object, BytesResource and SimpleLocatedResource check only whether a parent is set, geometry compares by its per-instance uuid (so the same URDF parsed twice gives unequal AddSceneGraphCommands), and Environment compares its timestamps, so two environments initialised separately are unequal while env == env.clone() holds. Environment.__eq__ releases the GIL, since the C++ operator takes the environment's lock. An operand of another class (MoveLinkCommand(j) == RemoveLinkCommand(l), cfg == 5) compares unequal without raising. ResourceLocator and Resource keep identity equality, because their C++ operator== returns true for any two objects. KinematicLimits checks the four matrix shapes before calling the C++ operator, which does not and would read out of bounds (#169).
before after
ContactRequest() == ContactRequest() → False True
env.clone() == env → False True (separately initialised: False, the timestamps differ)
seen = {cmd}, cache[env] = x TypeError: unhashable type; key on a stable field, e.g. {cmd.getType(): cmd}, cache[env.getName()], or id(env) for identity
cmd in history (identity) cmd in history (value); any(c is cmd for c in history) for identity
  • SWIG-era JointType_* constants removed — tesseract_scene_graph exported a module constant for each JointType value (JointType_FIXED, JointType_REVOLUTE, JointType_CONTINUOUS, JointType_PRISMATIC, JointType_FLOATING, JointType_PLANAR, JointType_UNKNOWN), kept from the SWIG bindings. C++ has no such names, and JointType is bound as an enum. All seven are gone: importing one raises ImportError, reading one as a module attribute raises AttributeError. Use the enum member; the values are the same objects. This finishes #176 for the scene graph module, which now joins its no-alias guard (#214).
before after
JointType_FIXED (also _UNKNOWN, _REVOLUTE, _CONTINUOUS, _PRISMATIC, _FLOATING, _PLANAR) JointType.FIXED (.UNKNOWN, .REVOLUTE, …)
from tesseract_robotics.scene_graph import JointType_FIXED from tesseract_robotics.scene_graph import JointType
  • PointCloudPoint renamed to PointCloud.Point — the point type of tesseract_geometry.PointCloud is the nested struct PointCloud::Point in C++, but was bound at module level as PointCloudPoint, a name C++ does not have. It is now bound nested, and PointCloudPoint and its __all__ entry are gone: importing it raises ImportError, reading it as a module attribute raises AttributeError. PointCloud.points is typed list[PointCloud.Point]. addPoint is unchanged and is still the way to grow a cloud (points converts to a fresh list on each access). Octree.update stays unbound: upstream's body is assert(false) (#209).
before after
PointCloudPoint(), PointCloudPoint(x, y, z) PointCloud.Point(), PointCloud.Point(x, y, z)
from tesseract_robotics.geometry import PointCloudPoint from tesseract_robotics.geometry import PointCloud, then PointCloud.Point
  • ChangeCollisionMarginsCommand(pair_margin_data) defaults to MODIFY, as upstream — the binding defaulted override_type to REPLACE, so leaving it out replaced every pair margin where the same C++ call merges the given pairs into the existing ones. Pass CollisionMarginPairOverrideType.REPLACE to keep the old behaviour (#247).
  • IfoptQPProblem and IfoptProblem removed; TrajOptQPProblem replaces them — code that builds IfoptQPProblem(IfoptProblem(nodes)) now fails with AttributeError: build TrajOptQPProblem(nodes) and add every constraint and cost set to it, each cost with its penalty type. It is not a rename, and results change: merit coefficients, names and violations are per set, not per row; addCostSet checks bounds; no cost bypasses the QP; the merit matches the model for squared costs; dynamic sets are accepted. docs/breaking-changes.md has the migration and the five differences (#148). trajopt is removing IfoptQPProblem (trajopt#595), and IfoptProblem was bound only to construct it. The online SQP example, the tests and the docs build TrajOptQPProblem, as tesseract_planning's planner and its online_planning_example.cpp do. The example added its velocity cost to the wrapped IfoptProblem, which kept it out of the QP (only IfoptQPProblem.addCostSet feeds the gradient and the Gauss-Newton Hessian) while the merit read it raw, so OSQP solved with no cost term and an empty Hessian: the global solve's squared joint steps summed to 23.2. As a squared cost they sum to 3.9, against 3.6 for the straight-line seed, and getTotalExactCost() reports that sum instead of the first velocity row.
  • The convex evaluators take the QP solution vector — evaluateConvexCosts, evaluateTotalConvexCost and evaluateConvexConstraintViolations raise trajopt_sqp.QPSolutionSizeError unless var_vals has exactly getNumQPVars() entries, the NLP variables followed by the slack variables, and trajopt_sqp.NotConvexifiedError before the first convexify(); both are ValueErrors. trajopt documents that size but does not check it. trajopt 0.35.0, which 0.35.0.8 and earlier bundle, multiplies a hinge or absolute cost's full QP rows into var_vals, so a shorter vector was read past its end: on a one-joint problem whose absolute cost is 0.5, a view of the first three entries of a longer buffer read 3.5. The pinned trajopt reads only the NLP block, but a vector shorter than getNumNLPVars() is still read past its end, and before the first convexify() a squared cost segfaults and a penalty cost or a constraint reads 0. What breaks: an NLP-sized var_vals on a problem with constraint sets and no hinge or absolute cost, which trajopt 0.35.0 read correctly; append zeros for the slack variables. A problem with no constraint sets and only squared costs has no slack variables, so nothing changes there. docs/breaking-changes.md has the migration (#149, #146).
  • SQPParameters.max_iterations → max_iter — trajopt renamed it (trajopt 9497159) and changed what it counts: the cap now applies to each penalty iteration, not the whole run, and rejected trust-region steps do not count. opt_params.max_iterations raises AttributeError; use opt_params.max_iter.
  • CartLineConstraint.getLinePoint is static — trajopt made it a static function (trajopt 9840e86). Calls on an instance still work, and it can now be called on the class.
  • Descartes: TaskComposer.plan raises ProfileTypeMismatchError on a profile of the wrong scalar type — every shipped Cartesian and raster task runs DescartesMotionPlannerF, which never finds a D profile: it planned with the library defaults (target pose fixed, no vertex margin) and reported success. plan now raises before it runs when a profile name in a Descartes node's namespace holds the other scalar type's move or solver profile but not the node's own; the message names the pipeline, node, namespace, profile name and both types. create_descartes_default_profiles(move_profile=…) registers the profile with its twin of the other type, so a Python subclass of DescartesMoveProfileD / DescartesMoveProfileF, whose hooks have no twin, is refused with ProfileOverrideNotDispatchedError (#350; docs/breaking-changes.md).

  • Python-surface renames and removals from the API audit — no aliases; the old names raise.

before after
Quaterniond(w, x, y, z), Quaterniond(coeffs=...) Quaterniond.from_xyzw(x, y, z, w) or Quaterniond([x, y, z, w]); Quaterniond(xyzw=...)
env.addEventCallback(key, EventCallbackFn(fn)), removeEventCallback(hash=), getJointGroup(name=, joint_ids=) key = env.addEventCallback(fn), removeEventCallback(key=), getJointGroup(group_name=, joint_ids=)
Environment.getStateByMap, getStateByNamesAndValues, setStateByNamesAndValues, getCurrentJointValuesByNames getState, setState(joint_ids, joint_values), getCurrentJointValues(joint_ids)
StateSolver.setStateByMap, setStateByNamesAndValues StateSolver.setState
JointGroup.calcJacobianWithPoint(q, link, p), KinematicGroup.calcInvKinMultiple(list, seed) calcJacobian(q, link, p), calcInvKin(list, seed)
common.VectorVector3d, common.VectorIsometry3d plain Python lists
MotionProgram.start_at, create_descartes_pipeline_profiles, TRAJOPT_PROFILE_NAMES add_target, create_descartes_default_profiles, STANDARD_PROFILE_NAMES
CartesianTarget(position=..., quaternion=...) CartesianTarget.from_xyz_quat(position, quaternion); CartesianTarget(pose)
planning.profiles._create_trajopt_profiles planning.profiles.create_trajopt_profile_pair
TaskComposer(config_path=...) removed; the config comes from get_task_composer_config_path()
emit_rapid returning a string; RapidEmitterError, Config.neutral_for, rapid.utils, core.naming.safe_identifier emit_rapid returns an EmittedProgram; the errors are named per failure mode
  • Changed behaviour from the API audit — failures raise where they returned a flag, None or a wrong value:
  • Environment.getLink / getJoint / getJointGroup / getKinematicGroup / getGroupJointIds / getLinkTransform and contact managers by name raise KeyError for a missing id (was RuntimeError).
  • InstructionPoly.as*Instruction() return views, so edits write through; a wrong cast raises PolyTypeError, a TypeError, for these and the WaypointPoly casts (was RuntimeError).
  • Hyperplane3d.Through(p0, p1, p2) follows Eigen: normal = (p2 - p0) x (p1 - p0), the sign the 0.35 binding flipped. A zero vector raises DegenerateGeometryError; only exactly zero counts as degenerate.
  • Isometry3d(matrix) and the rotation inputs of Isometry3d and AngleAxisd accept rotations only (NotRotationError); a non-unit quaternion or axis is normalized, a zero one raises DegenerateRotationError.
  • serialization.*_to_file returns None and raises OSError (was a bool), writes exactly path and takes a str or os.PathLike; the binary archives are bytes (were list[int]). urdf.writeURDFFile returns the written path and raises URDFWriteError (was a silent None).
  • Robot.ik raises IKNoSolutionError for an unreachable pose (was None); Robot.add_link, remove_link, move_link, add_allowed_collision, set_collision_margin and create_obstacle return None and raise EnvironmentCommandError (were bool).
  • TaskComposer.plan raises for an unknown pipeline, a malformed program or a missing pipeline port; only a planner that ran and found no solution returns successful=False. A pipeline without default profiles raises NoDefaultProfilesError.
  • TaskComposer.plan_ompl and the module-level plan_ompl default to FreespacePipeline (was OMPLPipeline); pass pipeline="OMPLPipeline" for raw OMPL.
  • A plugin-factory config path the locator cannot resolve raises FileNotFoundError instead of crashing the interpreter.
  • Planning failures raise named exceptions from tesseract_robotics.planning.errors, each subclassing the builtin it replaces.
  • Example main()s raise PlanningFailedError when a plan fails instead of printing and returning a failed result.
  • from tesseract_robotics.scene_graph import * no longer includes SceneState; import it by name.
  • planning, common and scene_graph define no __all__; planning.profiles is a package (trajopt, ompl, descartes, time_param, pipelines, names) and its name lists are tuples.
  • Emitters take frames from the ManipulatorInfo — emit_rapid returns an EmittedProgram and takes frames= and posture=; RapidProfile holds speed and zone only. emit_krl, emit_ls, emit_jbi and emit_urscript take a required frames= binding and raise UnboundFrameError for an unbound frame; emit_ls takes config=, emit_jbi a required calibration= (JbiPulseCalibration; JbiProfile has no tool). RAPID confdata needs the seed joints and an OpwPostureSolver; JBI positions are encoder pulses. SetToolInstruction raises UnsupportedInstructionError in every dialect, and program, module, procedure and signal names are validated per dialect (IdentifierError) instead of rewritten. The RAPID DSL declares typed objects (Robtarget, Tooldata, Speed, ...) inside with RapidWriter() as w:. Trajectory.from_composite and TesseractViewer.update_trajectory raise UntimedTrajectoryError for a program without waypoint times unless untimed_step_s= is given. docs/changes-0.36.md has the before/after.

Changes

Packaging, build and CI

  • One native build for CI and development — scripts/native_stack.py builds the C++ stack (vcs import, vcpkg, colcon) for wheels.yml and for pixi run native-build (.native/<triplet>); build/install compile the bindings against it through TESSERACT_CPP_PREFIX. The conda tesseract packages, the packaged and upstream envs and the feedstock submodules are gone. See docs/developer/native-stack.md (#162).
  • Python modules drop the tesseract_ prefix; sixteen are the compiled extension itself; the binding sources move to src/bindings/ — tesseract_robotics.tesseract_collision is now tesseract_robotics.collision, and likewise for 19 more (command_language, common, environment, geometry, kinematics, motion_planners, motion_planners_descartes, motion_planners_ompl, motion_planners_simple, motion_planners_trajopt, motion_planners_trajopt_ifopt, scene_graph, serialization, srdf, state_solver, task_composer, task_composer_planning, time_parameterization, urdf); trajopt_ifopt, trajopt_sqp, planning, viewer and emitters keep their names. No aliases: importing an old name raises ModuleNotFoundError. Sixteen modules (those 14 and trajopt_ifopt, trajopt_sqp) install as tesseract_robotics/<name>.abi3.so with a <name>.pyi stub and no __init__.py re-export wrapper (the six that hold Python code, common, scene_graph and the four motion_planners* packages, keep a package around a compiled _<name>). The C++ binding sources move from src/tesseract_<name>/tesseract_<name>_bindings.cpp to src/bindings/<name>.cpp. Upstream C++ names are unchanged. See docs/breaking-changes.md#036-module-names (#42).
  • Sources target Python 3.12 — ruff target-version = "py312" without FA102, PEP 695 aliases and generics, StrEnum for RapidType, zip(strict=True) in tests. The GIL-hotspot tooling tests move back to tests/test_gil_hotspots.py, in the wheel suite; the devtools-test task is gone (#369).
  • Wheels build on 3.12 only, and every test-wheel leg blocks — the 3.9, 3.10 and 3.11 builds and the cp39 cross-build (the py39 env) are gone. Python 3.14 no longer may fail (#369).
  • macOS builds share cereal's type registry with tesseract — since tesseract#1305 the polymorphic cereal registrations live in the libtesseract_* libraries, and conda's -fvisibility-inlines-hidden gave each image its own registry, so serialization raised Trying to save an unregistered polymorphic type. The build strips that flag on macOS, as the upstream recipes do; feedstocks bumped past #1305 need the same (#141).
  • macOS CI runs on macos-15 — GitHub retires the macos-14 image on 2026-11-02 and cancels its jobs during the scheduled brownouts before that (actions/runner-images#13518). The wheels are macosx_15_0 (Breaking changes above): the bundled Homebrew libomp sets that floor, not the runner.
  • The Windows wheel job no longer installs zip from Chocolatey — the wheel is repacked with Python's zipfile, so a Chocolatey feed outage (a 504 failed #353's build) no longer fails the job.
  • The Linux test-wheel job logs memory every 10 s — free memory and the five largest processes, so a runner that dies mid-suite ("received a shutdown signal", three times on x64) shows whether memory ran out.
  • GIL releases follow one rule, listed and checked in CI — KinematicGroup.calcInvKin, InverseKinematics.calcInvKin, TimeParameterization.compute, parseURDFString, parseURDFFile, the six tesseract_serialization environment_to_* / environment_from_* functions, generateInterpolatedProgram and the create{,Convex,SDF}MeshFrom{Path,Resource} mesh loaders release the GIL. Every binding that releases it is listed with its reason in scripts/nogil_entry_points.yaml; pixi run -e audit audit-gil (scripts/audit_gil.py, libclang) fails when a binding and the list disagree. docs/developer/threading.md states the rule and the known Environment event-callback limitation. pixi run gil-hotspots (scripts/gil_hotspots.py) ranks the bindings that hold the GIL longest in the benchmarks and tests, with py-spy --gil and a call-counting pytest plugin, to find new candidates; docs/developer/threading.md records the measured candidates and why each one is released or stays GIL-held (#124).
  • Docs build with Zensical — the site builds with zensical build --strict instead of MkDocs + Material for MkDocs (maintenance ends 5 November 2026; MkDocs 2.0 drops plugins). mkdocs.yml is read unchanged and renders the same 54 pages; strict mode now also fails on broken anchors. Zensical and mkdocstrings>=1 need Python ≥3.11, so the docs tooling moves out of the default pixi feature into a docs env (Python 3.12, no C++ stack): pixi run docs / pixi run docs-build run there (#252).
  • Every third-party import is a declared dependency — tests/scripts/test_runtime_dependencies.py checks each import in src/tesseract_robotics against [project] dependencies and the support extra, on every platform. An import test found pyyaml missing; it is declared now, and the test keeps the next one from slipping through.
  • The distribution declares its license — the repository gains LICENSE (Apache-2.0) and NOTICE, and pyproject.toml declares license = "Apache-2.0" with license-files = ["LICENSE", "NOTICE"] (PEP 639, so scikit-build-core 0.11 is the floor). Wheel METADATA now carries License-Expression: Apache-2.0 and one License-File per file, which is what pip and PyPI read; the license trove classifier is gone. tesseract-robotics-nanobind-support ships upstream tesseract's LICENSE.Apache-2.0 and LICENSE.BSD-3-Clause, the two texts its Apache-2.0 AND BSD-3-Clause expression names. Wheels up to 0.35.0.8 shipped without a license file (#368).
  • The PyPI project page names its platforms and links — the classifiers list Linux, macOS and Windows (they listed Unix and POSIX only) and Typing :: Typed, and [project.urls] gains Documentation, Changelog and Issues. The README's links are absolute: PyPI renders the wheel's README, where a repository-relative link is dead. tests/scripts/test_project_page_metadata.py and tests/docs/test_readme_structure.py check both.
  • tesseract_nanobind_selftest is an installed-package smoke check — imports, robot, kinematics, collision and a plan, with neither the test suite nor pytest.

Collision and geometry

  • Batch collision-object updates — CollisionObjectSpec and, on DiscreteContactManager and ContinuousContactManager, addCollisionObjects, removeCollisionObjects, setCollisionObjectsEnabled (a {id: bool} dict, or ids and one state), getCollisionObjectsTransform(id) and setCollisionObjectsTransform(ids, state), with setCollisionObjectsTransform(ids, state0, state1) on ContinuousContactManager for casts. Each batch is upstream's "the single calls in order": an id the manager does not hold returns False with the present ids still applied (remove, enable), or raises IndexError (get a transform); a state that lacks an id raises IndexError and moves nothing (#373).
  • Implicit SDF collision solver — ImplicitSDFShape (its distance / gradient may be Python callables; aabb is a (min, max) tuple), ImplicitSDFCollisionConfig, ImplicitSDFContact, collideImplicitSDF (GIL released) and makeImplicitSDFShape (#373).
  • SignedDistanceField geometry — a volumetric geometry that stores the signed distance to a surface on a grid, so concave shapes collide without convex decomposition (discrete contact managers only). createDiscreteSignedDistanceField samples a Python callable over the grid (batched=True hands it all points at once), the constructor takes a precomputed grid, and readSignedDistanceFieldVDB / readSignedDistanceFieldNVDB load OpenVDB / NanoVDB bytes. The geometry showcase example and the collision guide cover it (#129, @Joelkang).
  • Every ContactResult pair field raises on a wrong-length list — assigning type_id, link_names, shape_id, nearest_points or transform a list shorter than 2 kept the old value, and a longer list was cut to its first two items; neither raised. All pair fields are now bound directly on their native two-element arrays, so any other length raises TypeError, as cc_time and cc_type already did. The three pair fields that had no binding are added: subshape_id (default [-1, -1]), nearest_points_local and cc_transform, which a continuous contact test fills with the cast object's end pose (#172).
  • ContactResultMap readable by key, iterable and mutable — Python could only flatten a map. It now has at(key), getContainer() (a dict) and __iter__ over (key, ContactResultVector) pairs, plus addContactResult / setContactResult (single result or vector), shrinkToFit, filter(fn) and addInterpolatedCollisionResults. Every value handed out is a copy, and iteration walks a snapshot, so no Python reference into the map can dangle after an insert or shrinkToFit; only a filter callback gets the live vector, for the duration of the call. A missing key raises KeyError. Upstream only asserts two preconditions that the binding now enforces: a key with its link names out of order (which would be stored where no contact test looks) raises UnorderedLinkPairError, and an empty vector (whose last element upstream would read) raises EmptyContactResultsError; both subclass ValueError (#173).
  • Python can approve or reject contacts during a contact test — ContactResultValidator is bound as a subclassable class whose __call__(result) -> bool the managers call for each contact, and ContactRequest.is_valid takes one (None disables it). contactTest keeps releasing the GIL; the validator re-acquires it per call, so it works from worker threads, and an exception it raises propagates out of contactTest. The request keeps the validator object alive (#171).
  • ContinuousContactManager.setCollisionObjectsTransform takes start and end poses — the three cast (moving-object) overloads, (name, pose1, pose2), (names, poses1, poses2) and (transforms1, transforms2), were reachable only under the Python-only name setCollisionObjectsTransformCast. They are now overloads of the native name too, next to the three single-pose ones, as in C++. setCollisionObjectsTransformCast still works (#174).
  • ContactManagersPluginFactory binds its full API; managers keep the factory alive — Python can now list, add, remove and set the default discrete and continuous plugins, clear the search paths and libraries, create a manager from an explicit PluginInfo, and read (getConfig(), a YAML string) or save (saveConfig(path)) the config. Unknown names in remove… / setDefault… raise KeyError (upstream throws a generic runtime error), and saveConfig raises OSError when the file cannot be written (upstream ignores the failed write). Every create…ContactManager overload now ties the manager to the factory, since the manager's code lives in a plugin library the factory's loader owns (the gh-72 rule); before, dropping the factory first relied on the library staying mapped (#170).
  • tesseract_collision stubs name the geometry types — the collision extension never imported tesseract_geometry, so its stub spelled Geometry, Mesh and ConvexMesh as quoted C++ names ("tesseract::geometry::Geometry") in addCollisionObject, getCollisionObjectGeometries and makeConvexMesh, which type checkers cannot resolve. The extension now imports tesseract_geometry itself, and the stubs name the Python classes (#168).
  • createConvexHull bound; a failed hull raises ConvexHullError — Bullet's convex hull of a raw point set was reachable only through makeConvexMesh, which takes a Mesh. createConvexHull(input, shrink=-1, shrink_clamp=-1) returns the C++ out-params with the result as (n_faces, vertices, faces), where faces is the flat [count, i0, …] array. Upstream signals failure only by returning a negative face count, which happens when a positive shrink cannot be applied; the binding raises the new ConvexHullError (a RuntimeError) instead. An empty point set gives 0 faces, as upstream (#175).
  • V-HACD convex decomposition bound — ConvexDecompositionVHACD(params) splits a triangle mesh into a list of ConvexMesh hulls, configured by VHACDParameters (all ten fields, header defaults) and the FillMode enum under its native name; ConvexDecomposition is the abstract base, without a constructor. compute releases the GIL. Upstream reads the faces array without bounds checks, so the binding validates it first: a non-triangle face raises NonTriangleFaceError, a count running past the end or an out-of-range vertex index raises MalformedFacesError (both ValueError). The extension links tesseract's collision_vhacd component and does not compile a second V-HACD copy; a build-time #error and an nm test (Linux, macOS) guard that (#179).
  • Collision margin arithmetic on the margin types — CollisionMarginPairData and CollisionMarginData gain incrementMargins, scaleMargins, apply(pair_data, override_type) and the per-object getMaxCollisionMargin(obj); CollisionMarginPairData also gains getMaxCollisionMargin(). New constructors: CollisionMarginPairData({(a, b): margin, ...}), CollisionMarginData(default, pair_data) and CollisionMarginData(pair_data) (default margin 0). As upstream: the pair-data getters return None when no pair margin applies, while CollisionMarginData.getMaxCollisionMargin(obj) falls back to the default margin (#178).
  • Geometry.getUUID / setUUID bound — every geometry carries a UUID that == compares (Geometry::operator== is type and UUID, and each subclass's operator== starts from it), but Python could not read or set it, so Box(1, 1, 1) == Box(1, 1, 1) and geom == geom.clone() were False with no visible reason. getUUID() returns the canonical string; setUUID(str) sets it and raises ValueError for a malformed string, leaving the UUID unchanged, the spelling JointTrajectory.uuid uses. isIdentical still compares content (#206).
  • The full Mesh, SDFMesh and PolygonMesh constructors and the MeshTexture constructor bound — Python could build a mesh only from vertices and faces: Mesh and SDFMesh bound one (vertices, faces) constructor, PolygonMesh none, and MeshTexture had no constructor, so a mesh's resource, scale, normals, vertex colors, material and textures could be read back but never set. Each mesh class now binds both native constructors, (vertices, faces, resource=None, scale=…, normals=None, vertex_colors=None, mesh_material=None, mesh_textures=None) and the same with face_count after faces, with the C++ defaults (PolygonMesh also takes a trailing type=GeometryType.POLYGON_MESH); (vertices, faces) callers are unchanged. Upstream stores face_count without checking it; the binding counts the faces and raises the new MeshFaceCountError (a ValueError) when they disagree, before any object exists. MeshTexture(texture_image, uvs) takes a jpg or png Resource and the UVs; None for either raises TypeError. The API page's MeshMaterial and MeshTexture examples used attributes and a default constructor that never existed; they now use the bound constructors and getters (#207).
  • ConvexMesh.CreationMethod, getCreationMethod / setCreationMethod and the full ConvexMesh constructors bound; mesh classes compare with their own operator== — Python could not tell how a ConvexMesh was made, although the URDF parser records CONVERTED when tesseract:make_convex turned a mesh into its hull, and could build one only from vertices and faces. ConvexMesh.CreationMethod (DEFAULT, MESH, CONVERTED) is a nested enum, with no module constants; the getter and setter are bound, and ConvexMesh binds both native constructors through the #207 helper, so a wrong face_count raises MeshFaceCountError. PolygonMesh, Mesh, ConvexMesh and SDFMesh now bind their own operator== instead of inheriting Geometry's type-and-UUID comparison: two meshes with the same UUID compare unequal when their vertex count, face count or scale differ (for ConvexMesh also the creation method). SDFMesh keeps upstream's type-and-UUID comparison. ConvexMesh.clone() returns a DEFAULT mesh without normals, colors, material or textures, as upstream's does (convex_mesh.cpp:77) (#208).
  • createMeshFromBytes, createConvexMeshFromBytes and createSDFMeshFromBytes bound — Python could load a mesh from a path or a Resource, but not from bytes it already holds. The three instances of createMeshFromBytes<T> take (url, data: bytes, scale, triangulate, flatten, normals, vertex_colors, material_and_texture); the extension of url selects the format. The bytes are copied, so the meshes outlive data. triangulate defaults to True, as in the bound …FromPath / …FromResource siblings and the URDF parser, not false as in the header; the other flags keep upstream's False. The three …FromResource loaders, missing from tesseract_geometry.__all__, are added there with the new ones. createMeshFromAsset and extractMeshData take assimp types and stay unbound (#210).
  • The mesh loaders take normals, vertex_colors and material_and_texture — upstream's createMeshFromPath<T> / createMeshFromResource<T> take three flags to load a mesh's normals, vertex colors, materials and textures, but the six bound loaders took only (path_or_resource, scale, triangulate, flatten), so a textured .dae loaded from Python had none of them, although the same file parsed as a URDF visual did. All six now take the three flags after flatten, each False by default as in C++; with flatten and all three on, a loader returns what the URDF visual path returns. triangulate keeps its True default (#226).
  • Convex hull faces list only their own polygon — createConvexHull in the previous tesseract reused one face vector and never shrank it: a cube's hull came back with face sizes 4, 5, 6, 7, 8, 9 instead of six quads, and a V-HACD hull written to PLY and read back could lose a vertex. tesseract 13a2310f fixes it, so createConvexHull, makeConvexMesh, ConvexDecompositionVHACD.compute, AddTrajectoryLinkCommand's convex hull methods and URDF tesseract:make_convex meshes all return correct faces (tesseract#1382, #233, #235).
  • DiscreteContactManager.setCollisionObjectsTransform has one Mapping overload, and it releases the GIL — the binding had two map overloads, one taking the aligned TransformMap and one taking std::map. Both convert the same dict, so the stub listed setCollisionObjectsTransform(transforms: Mapping[str, Isometry3d]) twice, and nanobind, which takes the first overload that converts, never reached the second. Only that second overload was given a GIL release, so the release never applied. The unreachable std::map overload is removed, and the TransformMap overload, the one that runs, now releases the GIL during the transform update. ContinuousContactManager's single-pose map overload releases it too. A dict or any other Mapping converts as before (#241).
  • CompoundMesh == compares its meshes — == fell through to Geometry.__eq__, which compares type and UUID only, so two compound meshes with different meshes and one UUID compared equal. == / != are now upstream's CompoundMesh::operator==, which also compares every mesh (#247).

Environment, scene graph, kinematics and resources

  • PluginDiscoveryInfo, the base class of the four *PluginInfo types (#373).
  • JointTrajectory.insert(index, state) and del traj[i] / del traj[a:b], in Python's list forms, as CompositeInstruction has (#269).
  • The missing Environment getters bound — getInitRevision, getTimestamp, getCurrentStateTimestamp, getJointLimits, getLinkCollisionEnabled, getLinkVisibility, getLinkTransforms (all three overloads), getCurrentFloatingJointValues (both) and getContactManagersPluginInfo. The timestamps return a naive local-time datetime.datetime. getLinkTransforms(names, values[, floating_joints]) returns the C++ out-param as a dict and validates its input like setState (ValueError). A name that is not in the scene graph raises KeyError from getJointLimits, getLinkCollisionEnabled, getLinkVisibility and getCurrentFloatingJointValues(names), instead of None or an arbitrary bool. getJointLimits returns a copy (#188).
  • The remaining plugin-info structs bound — ContactManagersPluginInfo, ProfilesPluginInfo and TaskComposerPluginInfo had no binding, so nothing that takes or returns one could be bound either; KinematicsPluginInfo lacked CONFIG_KEY. All four now carry a read-only CONFIG_KEY, and the three new classes compare by value and are unhashable (__hash__ = None), through a new shared bind_value_equality helper. AddContactManagersPluginInfoCommand is bound too, with value equality, and Environment.applyCommand accepts it; its getter returns a copy, so editing it cannot change a command already in an environment's history (#164).
  • Every Resource is a ResourceLocator; GeneralResourceLocator binds its API — Resource was bound without its C++ base, so locateResource could not be called on a BytesResource or SimpleLocatedResource, and a BytesResource could not take the parent locator that resolves its relative urls. Both BytesResource constructors now take parent=None, and their arguments are named. GeneralResourceLocator gains its two native constructors, GeneralResourceLocator(paths=[...], environment_variables=[...]) and GeneralResourceLocator(environment_variables=[...]), plus addPath and loadEnvironmentVariable. Both constructors take keyword arguments only: a positional list[str] could be directories or environment variable names, so it raises TypeError. locateResource is typed Resource | None (#166).
  • JointTrajectory and AddTrajectoryLinkCommand bound — JointTrajectory had no binding, so nothing that takes or returns one could be bound. It now has both constructors, states, description, uuid (as its canonical string; a malformed string raises ValueError), the list protocol (len, indexing with negative indices, assignment, iteration) and push_back, pop_back, front, back, at, clear, empty, reserve, capacity, shrink_to_fit, max_size. Element access returns a copy, so write an edited state back with traj[i] = js; an index out of range, and front / back / pop_back on an empty trajectory (undefined behaviour in C++), raise IndexError. It compares by value and is unhashable. AddTrajectoryLinkCommand(link_name, parent_link_name, trajectory, replace_allowed=False, method=AddTrajectoryLinkCommand.Method.PER_STATE_OBJECTS) is bound with its getters, value equality and the nested Method enum (no Method_* module constants), and Environment.applyCommand accepts it with the GIL released; getTrajectory() returns a copy (#167).
  • The rest of AllowedCollisionMatrix, makeOrderedLinkPair and getAllowedCollisions bound — AllowedCollisionMatrix(entries) builds an ACM from the dict that getAllAllowedCollisions() returns, ordering each key as upstream does. New: the single-link removeAllowedCollision(link_name), which drops every entry involving the link, reserveAllowedCollisionMatrix(size), and str(acm) (C++ operator<<, one line per entry). The free functions makeOrderedLinkPair(a, b) (a tuple, smaller name first) and getAllowedCollisions(link_names, acm_entries, remove_duplicates=True) are bound too (#180).
  • ManipulatorInfo(manipulator, working_frame, tcp_frame, tcp_offset=Isometry3d.Identity()), empty and getCombined bound — only the default constructor was bound, so Python built a ManipulatorInfo field by field. As upstream: empty() is True unless manipulator, working_frame and tcp_frame are all set, and getCombined(override) takes every non-empty field of override, with an overriding tcp_frame bringing its tcp_offset along. Setting tcp_offset to anything but a str or an Isometry3d now raises TypeError, in the constructor and on the field, instead of RuntimeError: std::bad_cast; reading it still returns a copy (#181).
  • KinematicLimits.jerk_limits and resize, isWithinLimits and enforceLimits bound — jerk_limits is a read-write (n, 2) array like the other limit fields, and resize(n) resizes all four. isWithinLimits(values, limits) checks the bounds with no tolerance (unlike satisfiesLimits). enforceLimits(values, limits) returns the clamped values as a new array and leaves its input unchanged; C++ clamps in place. Upstream checks neither function's sizes, and a release build reads past the shorter operand, so both raise the new LimitsSizeMismatchError (a ValueError) when len(values) differs from the number of limit rows (#182).
  • Frame and error math from tesseract/common/utils.h bound — twistChangeRefPoint, twistChangeBase, jacobianChangeBase, jacobianChangeRefPoint, calcRotationalError, calcTransformError, all four calcJacobianTransformErrorDiff overloads and applyTolerances, under their native names. Python can now re-base a calcJacobian result to another frame or reference point, and get the transform error diff that handles the angle-axis ±π discontinuity, without re-deriving either in numpy. The twist, jacobian and applyTolerances functions work in place, as in C++: they return None and write into the array passed in, and raise TypeError for an array they would have to convert first (float32, read-only, non-contiguous, or a C-order (6, n > 1) jacobian), so the result is never written into a copy and lost. The twist and jacobian shapes, (6,) and (6, n), are part of the signature. A tolerance pair that is neither both empty nor both of the right size raises the new ToleranceSizeMismatchError (a ValueError); upstream raises a bare RuntimeError for applyTolerances and does not check the error-diff overloads (#184).
  • The command history readable and replayable; CommandType bound — CommandType was unbound, so Command.getType() raised TypeError on every call. Environment.getCommandHistory(), applyCommands(commands) and init(commands) (the inverse of getCommandHistory: the list must start with an AddSceneGraphCommand) are bound, and CommandAppliedEvent.commands holds the history at the event, as a copy that stays valid after the callback. Command lists are polymorphic: every element comes back as its own class, AddTrajectoryLinkCommand included. SetActiveDiscreteContactManagerCommand and SetActiveContinuousContactManagerCommand are bound with value equality, and applyCommand accepts them. As upstream, only these commands are recorded in the history: Environment.setActiveDiscreteContactManager(name) and its continuous twin are not (#186).
  • Every Environment state, joint-value, link-name, group and contact-manager overload under its native name — getState gains its three C++ overloads: (joints_dict, floating_joints={}), (names, values, floating_joints={}) and (floating_joints). setState gains floating_joints on both forms and a (floating_joints) form. Also new: getCurrentJointValues(names), getActiveLinkNames(names), getStaticLinkNames(names), getJointGroup(name, joint_names), and getDiscreteContactManager(name) / getContinuousContactManager(name), which return a copy built from any registered plugin. getState now validates its input like setState (ValueError). Before, an unknown or fixed joint name was added to the returned state without complaint, and a names/values length mismatch read joint values past the end of the array. A floating_joints key that is not a floating joint raises ValueError from every getState and setState form, as it already did from getLinkTransforms. Upstream raises IndexError, and in setState it does so after storing the joint values. A name that is not an active joint raises KeyError from getCurrentJointValues(names), which raised IndexError before. An unknown joint raises ValueError from the link-name getters and getJointGroup(name, joint_names). A plugin name that is not registered raises KeyError from the by-name contact-manager getters, where C++ returns null. The by-name managers keep their Environment alive (the gh-72 rule). getStateByMap, getStateByNamesAndValues, setStateByNamesAndValues and getCurrentJointValuesByNames still work: each is bound to the same function as its native overload, so they gain the same validation and the floating_joints argument (#187).
  • EnvironmentContactAllowedValidator bound — the validator Environment installs on every contact manager it creates or clones came back from getContactAllowedValidator() as the bare ContactAllowedValidator base, and Python could not build one. It is now bound in tesseract_environment as a subclass of tesseract_common.ContactAllowedValidator, with its SceneGraph constructor only: the C++ default constructor exists for serialization and leaves a null scene graph that __call__ would dereference, so EnvironmentContactAllowedValidator() and EnvironmentContactAllowedValidator(None) raise TypeError. A pair is allowed exactly when the scene graph's ACM allows it; the validator holds the scene graph by shared pointer, so it follows later ACM changes and keeps the graph alive (#189).
  • checkTrajectoryState (both managers) and checkTrajectorySegment bound — the single-step collision checks from tesseract/environment/utils.h had no binding. C++ fills a ContactResultMap& out-param and returns void; Python gets the map as the return value, a new one per call, so nothing accumulates across calls as it does in C++. The GIL is released for the contact test. Upstream reads each active collision object's transform with state.at(link), so a state map missing one threw std::out_of_range after moving the links before it; the binding checks first and raises KeyError naming every missing link, leaving the manager untouched (#190).
  • cast_CommandAppliedEvent / cast_SceneStateChangedEvent check the event type — both were an unchecked C++ static_cast, so passing the other kind of event was undefined behaviour; in practice the call silently returned the event unchanged and the caller hit AttributeError later. They now raise the new EventTypeError (a TypeError) naming the event's Events value and the expected one. Neither cast is needed in an event callback: the callback already receives CommandAppliedEvent or SceneStateChangedEvent, never the bare Event. The parameter is named evt (#191).
  • Python can supply TCP offsets: Environment.addFindTCPOffsetCallback bound — findTCPOffset could resolve only an Isometry3d or an SRDF group TCP, because nothing could register a find-TCP callback from Python. addFindTCPOffsetCallback(fn) takes fn(manip_info) -> Isometry3d; findTCPOffset asks the callbacks in registration order for any other name. clone() copies them, and the environment keeps them alive. A callback takes the GIL itself, so clone() keeps running without the GIL and findTCPOffset works from task-composer worker threads. As upstream, a callback that raises, or returns anything but an Isometry3d, counts as "not located": the next one is asked, and when none returns a transform findTCPOffset raises RuntimeError ("Could not find tcp by name …") without the callback's own exception. getFindTCPOffsetCallbacks and getEventCallbacks stay unbound: they return C++ std::functions that Python can neither inspect nor call usefully (#183).
  • CalibrationInfo and SRDFModel.contact_managers_plugin_info bound — SRDFModel.calibration_info was bound but its type was not, so reading it raised TypeError and the stub quoted the C++ name; SRDFModel.contact_managers_plugin_info had no binding. tesseract_common.CalibrationInfo now has joints (dict[str, Isometry3d], a copy on read: assign the whole dict or use insert), insert(other) (overwrites by joint name), clear(), empty() and a read-only CONFIG_KEY ("calibration"). It compares by value with upstream's tolerance (each transform isApprox(1e-5)) and is unhashable. SRDFModel.contact_managers_plugin_info holds the ContactManagersPluginInfo the SRDF's <contact_managers_plugin_config> points at, and saveToFile writes both configs beside the SRDF (#217).
  • Core-module stubs name the scene-graph, state, environment and program types — tesseract_kinematics, tesseract_serialization, tesseract_srdf and tesseract_state_solver used types another extension defines without importing it, so their stubs spelled 33 annotations as quoted C++ names ("tesseract::scene_graph::SceneGraph", "tesseract::environment::Environment", …), which type checkers cannot resolve. Each extension now imports the defining modules itself: kinematics → tesseract_scene_graph, tesseract_state_solver; serialization → tesseract_command_language, tesseract_environment, tesseract_state_solver; srdf and state_solver → tesseract_scene_graph. tesseract_scene_graph.SceneState (the class bound in tesseract_state_solver) is now re-exported on first access instead of at import, since an eager re-export would make the state-solver → scene-graph import a cycle; from tesseract_robotics.scene_graph import SceneState works as before (#218).
  • Every StateSolver state, Jacobian and link-transform overload under its native name, validated; insertSceneGraph bound — setState took only a full joint vector, the map and names-plus-values forms existed only as setStateByMap / setStateByNamesAndValues, no overload took floating_joint_values, and getLinkTransforms and MutableStateSolver.insertSceneGraph had no binding. setState now binds its four C++ overloads (vector, dict, names + values, each with floating_joint_values={}, and setState(floating_joint_values)), getState its five, getJacobian its three, and getLinkTransforms() / getLinkTransforms(names, values, floating_joint_values={}) (the C++ out-param returned as a dict). Every overload validates first: a joint name that is not an active joint, a floating name that is not a floating joint, names and values of different lengths, or a vector whose length is not the number of active joints raises ValueError; an unknown link in getJacobian raises KeyError. Before, OFKTStateSolver dereferenced a null node for an unknown joint name, so setStateByMap({"nope": 1.0}) crashed the interpreter (the GH #43 crash on the solver), and KDLStateSolver skipped it silently. setStateByMap and setStateByNamesAndValues still work: each is bound to the same function as its native overload, so they gain the validation and floating_joint_values. As upstream, KDLStateSolver ignores floating joint values and raises RuntimeError for setState(floating_joint_values) / getState(floating_joint_values). insertSceneGraph(scene_graph, joint, prefix="") returns upstream's bool (#219).
  • KinematicsPluginFactory binds its full plugin API; a group's last solver cannot be removed — Python could not list, add or remove a kinematics solver plugin, set a group's default solver, create a solver from an explicit PluginInfo, or read or save the config. KinematicsPluginFactory now binds add / get / remove / setDefault for FwdKinPlugin and InvKinPlugin (get…Plugins() returns a dict of group name → PluginInfoContainer), createFwdKin(solver_name, plugin_info, scene_graph, scene_state) / createInvKin(…) beside the group-name overloads, getConfig() (the YAML document as str) and saveConfig(file_path). As in ContactManagersPluginFactory (#170): setDefault… and remove… raise KeyError for an unknown group or solver, saveConfig raises OSError (FileNotFoundError for a missing directory) where upstream ignores a failed write, and every create… overload keeps the factory alive, since the solver runs code from a plugin library the factory loaded. Removing a group's last solver raises the new KinematicsPluginRemovalError (a RuntimeError) and leaves the factory unchanged: tesseract 0.35.0 erases the group and then reads, and for the default solver writes, through the erased iterator (kinematics_plugin_factory.cpp:150–154, reported upstream as tesseract#1381). getDefault…KinPlugin still raises RuntimeError for an unknown group (#211).
  • Every JointGroup.calcJacobian and KinematicGroup.calcInvKin overload under its native name; KinematicGroup constructor bound — calcJacobian took only (joint_angles, link_name), the link_point form existed only as calcJacobianWithPoint, and the two forms with a base_link_name (the frame the Jacobian is expressed in) were not bound; calcInvKin took a KinGroupIKInput or the opaque KinGroupIKInputs but not a list; KinematicGroup could only come from an Environment. calcJacobian now binds its four C++ overloads, (joint_angles, link_name), (…, link_name, link_point), (…, base_link_name, link_name) and (…, base_link_name, link_name, link_point), and every one raises KeyError for a link name the group does not have. Before, the two existing forms raised upstream's RuntimeError for an unknown link, and the new ones would have read an uninitialized transform in a release build (joint_group.cpp:197–198, :234–235). calcInvKin(list[KinGroupIKInput], seed) is bound. KinematicGroup(name, joint_names, inv_kin, scene_graph, scene_state) takes a clone of inv_kin, so the solver passed in stays usable, and keeps inv_kin (and so its factory) alive; upstream's checks raise RuntimeError. calcJacobianWithPoint and calcInvKinMultiple stay, bound to the same function as their native overloads (#212).
  • Kinematics utilities bound: numericalJacobian, calcManipulability, isNearSingularity, the harmonizers, isValid and checkKinematics — of tesseract/kinematics/utils.h only getRedundantSolutions was bound. Now: numericalJacobian (three overloads: a ForwardKinematics tip link, a JointGroup link, and a link relative to a base link with offsets; the 6 × n matrix is returned), calcManipulability with Manipulability / ManipulabilityEllipsoid (read-only fields), isNearSingularity(jacobian, threshold=0.01), harmonizeTowardZero / harmonizeTowardMedian (in place on a float64 array), isValid (six values) and checkKinematics(manip, tol=1e-3) from validate.h, which releases the GIL. Upstream reads or writes without checking in several of them, so the bindings check first: an unknown link raises KeyError and a wrong-length joint_values ValueError (numericalJacobian), a jacobian without 6 rows TypeError (calcManipulability), an empty matrix ValueError (isNearSingularity), and an index outside qs or position_limits IndexError with qs unchanged (the harmonizers). As upstream, a singular ellipsoid's measure and condition are sys.float_info.max, and checkKinematics returns True when IK finds no solution. solvePInv, dampedPInv and getRedundantSolutionsHelper stay unbound (#163) (#213).
  • Scene graph types print with upstream's operator<<; str(JointType.X) is upstream's name — JointDynamics, JointLimits, JointSafety, JointCalibration, JointMimic, ShortestPath and the JointType enum have an upstream operator<<, but none was bound, so print(joint.limits) showed a hand-written repr with two of six fields and print(path) the default object repr. Each now binds __str__ from it: str(JointLimits(-1, 1, 10, 2, 3, 4)) is "lower=-1 upper=1 effort=10 velocity=2 acceleration=3 jerk=4", and str(path) lists the links, joints and active joints. Changed: str(JointType.REVOLUTE) is now "Revolute" (upstream's spelling, "Unknown" for UNKNOWN), not "JointType.REVOLUTE"; .name and repr() are unchanged, so only code that formats a joint type with str() or an f-string sees the new text. The binding audit maps an operator<< on an enum to <Enum>.__str__ (#215).
  • Link.visible / collision_enabled, SceneGraph.setAllowedCollisionMatrix and getAdjacencyMap bound — Python could not hide a link or take it out of collision checking on the Link itself, although clone() copies both fields and == compares them; SceneGraph had no setAllowedCollisionMatrix and no getAdjacencyMap. Both fields are read/write. setAllowedCollisionMatrix(acm) keeps acm itself (later edits to it are edits to the graph's matrix, as with getAllowedCollisionMatrix); None raises TypeError and leaves the matrix in place, where upstream would store a null that the next ACM call dereferences. getAdjacencyMap(link_names) returns a dict mapping each listed link and every link below it, stopping at another listed link, to that listed link; an unknown name raises KeyError instead of upstream's RuntimeError. Link.getHash, SceneGraph.getVertex and getEdge stay unbound (#163) (#216).
  • tesseract_urdf.writeMeshToFile bound — tesseract/urdf/utils.h was not bound at all; its one function with a Python use is writeMeshToFile(mesh, filepath), which writes a mesh as the PLY file writeURDFFile references for every mesh it exports. It always writes ASCII PLY, whatever the extension; None for mesh raises TypeError (upstream dereferences it unchecked), and a path it cannot write raises RuntimeError. The urdf extension now imports tesseract_geometry, so its stub names PolygonMesh. The string helpers of the same header (toString, trailingSlash, noTrailingSlash, noLeadingSlash, makeURDFFilePath) stay unbound (#163). New API page tesseract_urdf (#220).
  • SceneState.floating_joints, getFloatingJointValues and == bound; the audit compares members of classes bound in another module — since #219 every StateSolver.setState / getState overload takes floating_joint_values, but the returned SceneState had no floating_joints, so Python could set floating joint values and not read them back. floating_joints is now a dict[str, Isometry3d] like link_transforms (a copy on read, assigned as a whole), getFloatingJointValues(joint_names) returns the named values and raises KeyError for a name that is not a floating joint (upstream throws std::out_of_range), and == / != are upstream's comparison: exact joint values, transforms within isApprox(1e-5); SceneState is unhashable. The binding audit missed the gap because SceneState is declared in a scene_graph header and bound in tesseract_state_solver: the class was accepted as bound in another module and its members dropped with it. They are now compared against the stub of the module that binds the class (#232).
  • SceneGraph.getJointChildrenNames takes a list of joint names — only the one-name overload was bound, so getJointChildrenNames(["joint_1", "joint_2"]) raised TypeError. The list overload returns the links below any of the joints, sorted and without duplicates, as upstream (graph.cpp:909–919); Environment calls it with the active joint names. A str still selects the one-name overload. The binding audit did not report the missing overload because it matches overloads by arity only, a documented limitation.
  • ChangeCollisionMarginsCommand(default_margin, pair_margin_data, override_type) — upstream's command that sets the default margin and the pair margins at once; override_type defaults to MODIFY, as upstream (#247).
  • OFKTStateSolver(root_name) — a solver holding the root link only, grown with addLink / moveLink (#247).
  • checkTrajectory, satisfiesLimits and the continuous contact fields bound (#158):
  • tesseract_environment.checkTrajectory binds all four C++ overloads: a discrete or continuous manager, each with either a StateSolver plus joint names or a JointGroup. The C++ contacts out-parameter is returned instead: the call returns (ContactTrajectoryResults, list[ContactResultMap]). The GIL is released while the trajectory is checked.
  • ContactTrajectoryResults, ContactTrajectoryStepResults and ContactTrajectorySubstepResults are new in tesseract_collision. Their table and summary methods return str.
  • ContactResult.cc_time and cc_type (two entries each) are bound. Assigning a list of any other length raises TypeError.
  • tesseract_common.satisfiesLimits has a scalar-tolerance overload, with the C++ defaults (max_diff=1e-6, max_rel_diff = double epsilon), and a per-joint-tolerance overload.

Motion planners

  • Sample-grid utilities — PositionerSampleResolution, gatherJointLimits, buildSampleGrid and computeChainReachUpperBound in tesseract_kinematics. The REP / ROP / RTP plugin internals (factory_utils.h, rtp_factory.h, rtp_inv_kin.h) stay unbound: the plugins are reached through KinematicsPluginFactory (#373).
  • Descartes memory: the Bullet pool-size workaround is documented — the Descartes warning in docs/user-guide/planning.md shows the plugin config that shrinks the per-clone pools from 4096/4096 to 16/16, with #140's measurements; test_bullet_pool_config.py checks the small pools give the same contacts (#140).
  • OMPL optimization objectives from Python — a Python subclass of OMPLRealVectorMoveProfile overrides createOptimizationObjective(si, env, manip) and returns an objective built from the newly bound SpaceInformation, Cost, OptimizationObjective (isSatisfied, setCostThreshold, getCostThreshold), PathLengthOptimizationObjective, MaximizeMinClearanceObjective, MechanicalWorkOptimizationObjective and MultiOptimizationObjective.addObjective(objective, weight). A cost threshold ends the optimize loop at the first path that meets it instead of at planning_time; a wrong return type raises OMPLObjectiveReturnTypeError. tesseract_freespace_clearance_objective_example plans a KUKA IIWA sweep through six rotated cubes both ways and shows the thresholded plan in the viewer. tesseract's OMPL validators report no clearance, so the clearance term is constant and the weighted objective reduces to path length (#362).
  • StateCostIntegralObjective with a Python stateCost — subclass it and override stateCost(self, values) -> float to price states in Python; values holds the state's joint positions. The planner integrates the cost along the path, so an objective can weigh where the path goes, not only how long it is. Without an override every state costs 1 and the integral is path length. A non-float return raises OMPLStateCostError, and a Python error in the override propagates from solve. Each call takes the GIL. An optimizing planner (RRT*) calls stateCost on its own thread, where a raising override aborts the process; use it with RRTConnect (#362).
  • TrajOptCollisionConfig(margin, coeff, request, type, longest_valid_segment_length, check_program_mode) — the full upstream constructor; the two-argument form still works (#251).
  • OMPLSolverConfig.simplify_time bound — the time budget for path simplification when simplify is set: <= 0 (the default) runs it to completion, > 0 bounds it in seconds (#120, @Joelkang).
  • Motion-planner core: the rest of utils.h, request reasons, robot configuration — toToolpath (three overloads), formatProgram and contactCheckProgram (discrete and continuous; returns (ContactTrajectoryResults, list[ContactResultMap]) with the GIL released) (#303); MotionPlanner.checkRequestReason(request) -> str and MotionPlanner.assignSolution (#332); RobotConfig, getRobotConfig, getJointTurns, isWithinJointLimits (#333; isValidState<double> does not compile upstream and stays unbound). The module imports the modules that define Environment, CompositeInstruction and ProfileDictionary, so its stub names them instead of quoting C++ names (#300).
  • Simple planner — SimpleMotionPlanner derives from MotionPlanner (#299); interpolate (poses and joints), interpolate_waypoint and getInterpolatedInstructions (#305); SimplePlannerMoveProfile.generate (#339); SimplePlannerMoveProfile.createKey() / SimplePlannerCompositeProfile.createKey(), inherited by every concrete profile, return the key the profile registers under (#273); from_yaml(text) on the seven move profiles (#331).
  • All 14 OMPL planner configurators — ESTConfigurator, LBKPIECE1Configurator, BKPIECE1Configurator, KPIECE1Configurator, BiTRRTConfigurator, RRTConfigurator, TRRTConfigurator, PRMConfigurator, PRMstarConfigurator, LazyPRMstarConfigurator and SPARSConfigurator join the three already bound, one per OMPLPlannerType, with every public field. create stays unbound: it takes OMPL types (#301).
  • OSQPSettings and TrajOptOSQPSolverProfile.settings — the classic TrajOpt planner's QP solver is tunable from Python: tolerances, iteration and time limits, polishing, adaptive rho. OSQPSettings() holds OSQP's defaults, a new profile trajopt's. The OSQP enum fields linsys_solver and cg_precond are not bound (#306).
  • TrajOptDefaultCompositeProfile.computeLongestValidSegmentLength — the static helper that turns a longest-valid-segment fraction and length into the collision-check step (#307).
  • FixStateCollisionProfile binds its TrajOpt correction fields — trajopt_joint_constraint_config, trajopt_joint_cost_config, collision_constraint_coeff, collision_cost_coeff, opt_params and osqp_settings; tesseract_task_composer_planning now imports tesseract_motion_planners_trajopt and trajopt_ifopt at load (#326).
  • OMPLMotionPlanner and TrajOptMotionPlanner derive from MotionPlanner — isinstance(planner, MotionPlanner) holds, and MotionPlanner.solve(planner, request) dispatches to the planner (#299).
  • Profile hooks OMPLMoveProfile.createSolverConfig and TrajOptSolverProfile.createOptimizationParameters — Python can read what the planner builds from a profile (#339).
  • Static createKey() on the OMPL, TrajOpt and task-composer planning profiles — returns the key ProfileDictionary uses, without building a profile. The OMPL and TrajOpt keys belong to the profile kind (OMPLMoveProfile, TrajOptMoveProfile, TrajOptCompositeProfile, TrajOptSolverProfile) and are inherited by the concrete profiles (#273).
  • from_yaml on the OMPL, TrajOpt and task-composer planning profiles — OMPLRealVectorMoveProfile, TrajOptDefaultMoveProfile, TrajOptDefaultCompositeProfile, TrajOptOSQPSolverProfile and the seven tesseract_task_composer_planning profiles load from YAML text through the C++ YAML constructor. A key replaces the whole sub-config it names, starting from that config's own defaults (collision_check_config: {...} resets type to DISCRETE; solver_config: {...} starts with no planners). Malformed YAML raises ValueError, a value of the wrong type the profile's RuntimeError (#331).
  • TrajOpt-Ifopt and Descartes planners are MotionPlanners — TrajOptIfoptMotionPlanner and DescartesMotionPlannerD derive from tesseract_motion_planners.MotionPlanner; getName/solve/terminate/clear/clone are the base's (its solve releases the GIL) (#299).
  • The Descartes stub names Environment — the binding imports tesseract_environment, so DescartesMoveProfileD.create* no longer quote "tesseract::environment::Environment" (#300).
  • DescartesStateSampleD(state) and str() on Descartes waypoint samplers — the one-argument constructor (cost 0) and __str__ from upstream's print (#310).
  • Descartes tool-pose samplers — sampleFixed, sampleToolAxis, sampleToolXAxis, sampleToolYAxis, sampleToolZAxis, returning tesseract_common.VectorIsometry3d (#311).
  • TrajOpt-Ifopt profile hooks — TrajOptIfoptMoveProfile.create, TrajOptIfoptCompositeProfile.create and TrajOptIfoptSolverProfile.create, with the structs they return: TrajOptIfoptTermInfos and the move-only TrajOptIfoptWaypointInfo (its node read-only and keeping the info alive) (#339).
  • createKey() on the TrajOpt-Ifopt and Descartes profile bases — TrajOptIfopt{Move,Composite,Solver}Profile.createKey() and Descartes{Move,Solver}ProfileD.createKey() return the key every profile of that kind carries; subclasses inherit it (#273).
  • TrajOpt-Ifopt profiles load from YAML text — TrajOptIfoptDefaultMoveProfile.from_yaml, TrajOptIfoptDefaultCompositeProfile.from_yaml and TrajOptIfoptOSQPSolverProfile.from_yaml(config) run the C++ YAML constructor; malformed YAML raises ValueError, a value of the wrong type the constructor's RuntimeError (#331).
  • Python-authored simple-planner move profiles — subclass SimplePlannerMoveProfile and override generate; its instruction and manipulator-info arguments arrive as copies, so an override may keep them. A generate that returns an empty list or a null instruction raises SimplePlannerEmptyGenerateError / SimplePlannerNullInstructionError (both ValueError; upstream would read past the end or plan the null as a success). super().generate(...) from such an override raises SimplePlannerPureVirtualCallError (a NotImplementedError; the base is pure virtual). An exception generate raises propagates from SimpleMotionPlanner.solve with its type when the plan fails (the last one raised wins; upstream turns it into a failed response, and the MotionPlanner base solve and the task composer still do). A profile without generate raises SimplePlannerPureVirtualCallError from solve, a generate returning anything but a list of MoveInstructionPoly raises SimplePlannerProfileReturnTypeError (a TypeError naming the offending element's type), and one whose last instruction differs from base_instruction in move type, waypoint type, profile or path profile raises SimplePlannerGenerateMismatchError (a ValueError; upstream asserts this in debug builds only). The helpers a C++ override calls are bound: JointGroupInstructionInfo / KinematicGroupInstructionInfo (each keeps its instruction and environment alive), the twelve interpolate{Joint,Cart}{Joint,Cart}Waypoint overloads and both getClosestJointSolution overloads (the pair one returns a tuple). JointGroupInstructionInfo.getWorkingFrame is declared upstream but never defined and stays unbound (#340).
  • DescartesMoveProfileD.createKinematicGroup(manip_info, env) — the helper a C++ Descartes override calls; the returned KinematicGroup keeps env alive, whose kinematics plugins hold its IK solver code (#340).
  • Python-authored TrajOpt-Ifopt move and composite profiles — subclass TrajOptIfoptMoveProfile or TrajOptIfoptCompositeProfile and override create; a composite profile can add Python ConstraintSets to the terms it returns, and those sets are released safely on a task-composer worker thread. An exception create raises propagates from solve with its type. super().create(...) from such an override, or a subclass without create, raises TrajOptIfoptPureVirtualCallError (a NotImplementedError). A move profile's create must return an info that has a node (TrajOptIfoptWaypointInfoWithoutNodeError) and that nothing else references, since the planner takes its node (TrajOptIfoptWaypointInfoInUseError, decided by the reference count, which is exact on the GIL builds shipped); any other return type raises TrajOptIfoptProfileReturnTypeError. A composite create that changes the planner's (read-only) nodes raises TrajOptIfoptNodeLayoutChangedError: added variables would change the problem's layout, and changed values would be silently overwritten by the planner's seed. TrajOptIfoptSolverProfile.create stays non-overridable: it returns the concrete TrustRegionSQPSolver (#340).
  • Overriding a hook on a concrete profile raises — only the abstract bases forward virtual calls to Python, so a generate / create / create* override on a Python subclass of a concrete profile (the seven simple-planner move profiles, TrajOptIfoptDefault{Move,Composite}Profile, TrajOptIfoptOSQPSolverProfile, DescartesDefaultMoveProfileD, DescartesLadderGraphSolverProfileD) was silently never called. Such a class statement now raises ProfileOverrideNotDispatchedError (a TypeError, exported by each planner module), naming the abstract base to subclass instead (#340).
  • float Descartes types — DescartesMoveProfileF, DescartesDefaultMoveProfileF, DescartesSolverProfileF, DescartesLadderGraphSolverProfileF, DescartesMotionPlannerF and the descartes_light types DescartesStateF, DescartesStateSampleF, DescartesEdgeEvaluatorF, DescartesWaypointSamplerF, DescartesStateEvaluatorF, bound from the same template as their D twins: the same fields, createKey(), value equality and Python subclassing; states hold float32 values. planning.profile_types.descartes_nodes(factory, pipeline, node) lists the Descartes nodes a pipeline runs, with the namespace and scalar type each reads (#350).

TrajOpt-Ifopt, SQP and constraints

  • CartAxisKinematics, calcJacobianBlock on CartAxisAlignConstraint / CartAxisConeConstraint, CollisionCoeffData.hasZeroCoeff — the CartAxis constraints now check their Var against the linked set, as the other Var-based constraints do (#373).
  • PIQP solver profiles compare and load from YAML — TrajOptPIQPSolverProfile and TrajOptIfoptPIQPSolverProfile get == / != and from_yaml(text); checkPIQPSettings(settings, profile_name) raises for settings PIQP's sparse backend rejects. PIQPSolver.solver() stays unbound: it returns a piqp::SparseSolver, which no module binds (#373).
  • Velocity, acceleration and jerk bands: the list[Bounds] constructors of JointVelConstraint, JointAccelConstraint and JointJerkConstraint — JointVelConstraint(bounds, position_vars, coeffs, name, range_bound_handling) and its siblings take one bound per joint, repeated for every step. A range splits into a lower-bound row and an upper-bound row by default, so a symmetric band Bounds(-v, v) works as a constraint in TrajOptQPProblem; KEEP_AS_IS keeps it whole, which TrajOptQPProblem refuses. trajopt 0.35.0 declared these constructors without defining them; until trajopt#628 merges, the dev conda trajopt (build 3) carries it as patches and the wheels build trajopt from its branch (dependencies.rosinstall). tesseract-robotics-planning build 1 is rebuilt against that trajopt: the patches add a member to the joint difference constraints, and build 0 crashed in createJointVelocityConstraint against the patched layout (#290).
  • InverseKinematicsConstraint.calcJacobianBlock(joint_vals) — returns the Jacobian at joint_vals as a sparse matrix, like the other three constraints' (#289).
  • trajopt_ifopt.getGradient — binds both trajopt_common::getGradient overloads, getGradient(dof_vals, contact_result, margin, margin_buffer, manip) for one discrete contact and getGradient(dof_vals0, dof_vals1, contact_result, margin, margin_buffer, manip) for a continuous one, returning GradientResults; the evaluator supplies getCollisionMarginData(), getCollisionMarginBuffer() and getJointGroup() (#141).
  • A callback's False stops the solve — the 0.36 trajopt ends the solve after that call with SQPStatus.STOPPED_BY_CALLBACK, and TrajOptIfoptMotionPlanner's response fails with SQP_STOPPED_BY_CALLBACK. trajopt 0.35.0 dropped the False and kept stepping; the low-level SQP guide's warning becomes a note.
  • Python SQP callbacks reach the TrajOpt-Ifopt planner — TrajOptIfoptSolverProfile.callbacks (copied on access; None rejected) and createOptimizationCallbacks(). A callback returning False stops the solve, and the planner's response fails with SQP_STOPPED_BY_CALLBACK (#308).
  • The TrajOpt-Ifopt term factories — createJointPositionConstraint, createCollisionConstraints, createJointVelocityConstraint, createJointAccelerationConstraint, createJointJerkConstraint from trajopt_ifopt_utils.h; an empty or None-holding vars raises (#309).
  • trajopt_ifopt names its tesseract types — the extension imports tesseract_kinematics and tesseract_environment, so its signatures and stub name JointGroup, KinematicGroup and Environment instead of quoted C++ names (#285).
  • The planner's collision constraints — DiscreteCollisionConstraintD, ContinuousCollisionConstraintD (one row per contact) and ContinuousCollisionNumericalConstraint are bound; trajopt_ifopt and trajopt_sqp drop __all__, so the star import re-exports every bound name, toString included (#291, #284).
  • Collision evaluator queries — calcCollisions / calcCollisionData return a CollisionCacheData; getGradient, calcGradientData and getJointGroup are bound on the two evaluator bases, with the trajopt_common result structs (LinkGradientResults, GradientResults, LinkMaxError, GradientResultsSet, CollisionCacheData) (#292).
  • Bounds += s / Bounds -= s shift both limits and reclassify the bounds type; the name keeps the Bounds (#286).
  • Component.getValues / getBounds, Differentiable.getJacobian and Differentiable.Mode are bound on the bases (#287).
  • Constraint accessors — setBounds on every constraint that declares it (raises BoundsSizeError unless one bound per row), CartLineConstraint.getLine / getInfo, InverseKinematicsConstraint.setTargetPose / getKinematicInfo (#288).
  • calcJacobianBlock(joint_vals) on CartPosConstraint, CartLineConstraint and DiscreteCollisionNumericalConstraint: the Jacobian at given joint values, sized like getJacobian(); raises JointValuesSizeError on a wrong length. InverseKinematicsConstraint.calcJacobianBlock stays unbound: the pinned trajopt declares it but does not define it (trajopt#626) (#289).
  • CartLineInfo(...) / InverseKinematicsInfo(...) field constructors, with the C++ defaults as overloads. The list[Bounds] constructors of JointVel / JointAccel / JointJerkConstraint stay unbound: the pinned trajopt declares them but does not define them (trajopt#606) (#290).
  • CollisionCoeffData.getCollisionCoeffPairData / getPairsWithZeroCoeff (#293).
  • getClosestValidPoint, calcBoundsErrors, calcBoundsViolations (#294).
  • calcNumericalConstraintGradient(variables, constraint_set) and calcForwardNumJac(f, x, epsilon) check an analytic Jacobian, a Python ConstraintSet's included (#295).
  • trajopt_ifopt.python_constraints: a constraint from f(q) — PyConstraint is a ConstraintSet base that takes a rule's values at one waypoint's joints, lower <= f(q) <= upper, and supplies the bounds, the coefficients and the Jacobian: a forward difference over that waypoint's joints (calcForwardNumJac) placed in its columns, or an analytic jacobian(q). A range row is split into two one-sided rows, since TrajOptQPProblem takes none. Rules built on it: PointsDown, HoldAxis, StayDexterous, ElbowUp, WatchTheTool, Clearance and WorldHold; the two cosine rules are bounded below only, since a row at 1 sits on its bound with a vanishing gradient when the axis is aligned; the first two are the worked examples next to trajopt's CartAxisConeConstraint and CartAxisAlignConstraint, which the tests check them against. build_optimization_problem and run of the online SQP example take extra_constraints, a callable returning the sets to add, and run takes num_replan. scripts/bench_python_constraints.py measures what a rule costs in that loop against CartAxisAlignConstraint. See docs/user-guide/low-level-sqp.md.
  • toTrajArray(vars) / toJointTrajectory(vars); the online SQP example reads its warm start with toTrajArray (#296).
  • NodesVariables(name, nodes) and the Var constructors — Python builds variable sets with several vars or per-node bounds; the Nodes hand over ownership. Var.getParent / Node.getParent (#297).
  • QPProblem convex model and setVariables — getHessian, getGradient, getConstraintMatrix, getBoundsLower, getBoundsUpper, getConstraintMeritCoeff, and setVariables(x), which raises VariablesSizeError unless len(x) == getNumNLPVars() (#282).
  • QPSolver update interface — updateHessianMatrix, updateGradient, updateLowerBound, updateUpperBound, updateBounds, updateLinearConstraintsMatrix and setWarmStart(problem) on the base; OSQPEigenSolver.setWarmStart takes a bool (the OSQP option) or a QPProblem (#283).
  • PIQP solver bound — trajopt and tesseract_planning master add PIQP, an interior-point QP solver (trajopt 3b3eab1, d6d3891; tesseract_planning 77cb4b9, 77ade71). trajopt_sqp.PIQPSolver (with PIQPSettings, PIQPKKTSolver and PIQPSolver.defaultSettings()) drops into TrustRegionSQPSolver in place of OSQPEigenSolver, and TrajOptPIQPSolverProfile / TrajOptIfoptPIQPSolverProfile select it in the planners. The bindings require a trajopt built with PIQP; against one without it they fail to compile.
  • CartAxisConeConstraint and CartAxisAlignConstraint bound — trajopt#602: the cone keeps a link axis within a half angle of a target axis (one row, the angle), the alignment points it along the target axis (two equality rows); rotation about the axis stays free in both, which a CartPosConstraint with a dropped rotation row cannot express without discontinuities at a half turn.
  • SQPParameters.sum_constraint_set_violations bound — whether cnt_tolerance is tested against a set's summed row violations (the default) or its largest row (trajopt 9be7dcd); tesseract_planning reads and writes it in the TrajOpt-Ifopt solver profile's YAML. QPProblem.setSumConstraintSetViolations sets the same reduction on a problem directly.
  • ConstraintSet.getJacobian() before linkWithVariables raises ConstraintNotLinkedError instead of crashing — every built-in trajopt_ifopt constraint sizes its Jacobian from the linked variable set without a null check, so calling getJacobian() on a constraint not yet linked (directly or by adding it to a problem) segfaulted, for all ten bound constraint classes. The binding checks the link first and raises the new trajopt_ifopt.ConstraintNotLinkedError (a RuntimeError) naming the set. No other bound member reads the linked variables. A Python ConstraintSet subclass is unaffected: its own getJacobian replaces the bound one (#202).
  • TrajOptQPProblem bound — the QP problem tesseract_planning's TrajOpt-Ifopt planner builds is now reachable from Python: construct it over the node variables (TrajOptQPProblem(createNodesVariables(...))) and add costs and constraints directly, with no IfoptProblem layer. Every row of a set must be an equality or bounded on one side, with any penalty type; a two-sided range row raises when the set is added (trajopt c1bd090, 95a3325, bb3d6e6). Its exact merit weights each cost row and each constraint set's violation by their coefficients, as its convex model does, and counts every cost term once, so the trust-region ratio compares like with like for every penalty type: an ABSOLUTE or HINGE cost is modelled on its linearized rows (trajopt#592). IfoptQPProblem, the only problem 0.35.0.8 and earlier bind, does neither (trajopt#595). One merit coefficient per constraint set (#145, #151).
  • ConstraintSet.getJacobian() returns every set's Jacobian — the collision constraints (analytic and numerical, discrete and continuous) assemble their Jacobian with coeffRef while a contact is active, which leaves it uncompressed, and nanobind's Eigen caster refused it: getJacobian() raised for exactly the rows a caller needs. The binding now returns a compressed copy.
  • JointPosConstraint's bounds constructor bound — one bound per joint (equality, one-sided or range) as an additive overload next to the target constructor; a range becomes two one-sided rows unless range_bound_handling=KEEP_AS_IS. A coeffs of length 0 weights every joint 1, and one of length 1 gives every joint that weight (trajopt#592) (#146).
  • Python ConstraintSet subclasses report getNonZeros() == 0 — the Jacobian non-zero hint kept trajopt's unset default of −1, which Python could not change. TrajOptQPProblem reserves storage from the sum of its cost hints, so a Python cost set on its own raised ValueError: vector. 0 is a valid hint: storage grows as needed.
  • SQPCallback receives the problem itself, not a copy — nanobind's default automatic_reference policy copies lvalue-reference arguments, deep-copying the whole QP problem on every trial and aborting on a non-copyable problem (TrajOptQPProblem). The problem now arrives by reference (the same Python object that was passed to solve); results is still a per-trial copy.

Task composer and time parameterization

  • Config schemas — schema() on TaskComposerGraph, TaskComposerPipeline, TaskComposerTask(ports) and TaskflowTaskComposerExecutor; TaskComposerNodePorts.inputSchema() / outputSchema(); ValidationError.toString(). A schema is a tesseract_common.PropertyTree, whose YAML crosses as text: applyConfig(text) returns every error, naming each key the schema does not declare (#373).
  • Task composer: the rest of the C++ API — TaskComposerKeys list ports, remove, rename, __str__ (#313); TaskComposerDataStorage(name), getData(), remapData, copyAsInputData / copyAsOutputData (#314); TaskComposerFuture.clear / copy (#315); uuid-addressed node, info and container members as canonical uuid strings, and native getDotgraph / saveDotgraph(results_map) (#316); TaskComposerContext constructors and abort, and a name for the run(node, data_storage) shortcut (#317); TaskComposerNodeType, TaskComposerNodePorts and the node's setters, type, ports, validatePorts, getDataStorage and synchronous run (#318); every TaskComposerNodeInfo field, read-write, start_time as datetime (#319); TaskComposerNodeInfoContainer.find, prune, addInfo, insertInfoMap, mergeInfoMap, clear (#320); TaskComposerPluginFactory search paths and libraries, plugin add/remove/default, creation from a PluginInfo, getConfig / saveConfig, executor plugin listing (#321); TaskComposerServer (#323); TaskComposerTask, TaskComposerGraph (with addNode) and TaskComposerPipeline, so factory pipelines expose their children (#324); TaskComposerLog, and tesseract_serialization.task_composer_log_{to,from}_{xml,file,binary} to save a run for replay; the _file pair writes and reads XML at exactly the path given (a str or an os.PathLike; no .tclx appended) and raises OSError when it cannot. A log whose data holds planner profiles cannot be serialized in the 0.35 bindings (the profile types are not registered with the serialization module): store an empty ProfileDictionary (#325).
  • AnyPoly.getTypeName is demangled — tesseract::command_language::CompositeInstruction on every platform, not the compiler's mangled name (#322); the AnyPoly_* signatures name the Python types (#312).
  • Command-language bindings complete — instruction UUIDs as canonical strings (getUUID/setUUID/getParentUUID/setParentUUID/regenerateUUID on the nine instruction types, #262); copy.copy/copy.deepcopy on the waypoints, instructions and Polys (#263); WaypointPoly, MoveInstructionPoly and InstructionPoly built from the types they wrap, the full MoveInstruction (path profile, manipulator_info) and five-argument StateWaypoint constructors (#264); profile overrides (#265); createChild/isChild, create*Waypoint, isLinear/isFreespace/isCircular (#266); tolerances, setSeed, effort on the waypoint Polys (#267); as* casts returning references on the waypoint and move-instruction Polys (#268); CompositeInstruction insert, __delitem__, pop_back, front/back/at and capacity members (#269), traversal (flatten, getFirst/Last(Move)Instruction, counts, moveFilter, #270) and getUserData/setUserData (#271); ProfileDictionary.addProfile for several names, getProfileEntry, getAllProfileEntries (#272); the utils.h functions (toJointTrajectory, joint-position helpers, clampToJointLimits, makeTimeMonotonicallyIncreasing, toDelimitedFile, #274; validateSeedStructure is not bound: declared in utils.h, not defined in tesseract 0.35.0).
  • Ruckig jerk-limited smoothing — RuckigTrajectorySmoothing and RuckigTrajectorySmoothingCompositeProfile (duration_extension_fraction, max_duration_extension_factor, override_limits, velocity_limits, acceleration_limits, jerk_limits) are bound; the module links tesseract::time_parameterization_ruckig (#278).
  • rescaleTimings(program, scalings) — rescales each sub-composite's timing in place; a scalings list that is not len(program) long raises the new ScalingsLengthError (a ValueError; upstream only asserts) (#279).
  • ISPCompositeProfile.minimum_time_delta is bound (#280).
  • createKey() on the time-parameterization profiles — a static X.createKey() returns the ProfileDictionary key X().getKey() without building a profile, on all five profile classes (#273).
  • plan_freespace, plan_ompl and plan_cartesian take a composer — each call built a new TaskComposer and loaded the task composer plugins again, about 4.3 s on macOS arm64, so a 419-waypoint Descartes solve that takes 0.47 s through a held composer took about 5 s through plan_cartesian. A keyword-only composer= plans through the given composer and loads nothing; the caller owns its lifetime, so no module-level composer outlives interpreter teardown. Without one, the wrappers behave as before (#137).
  • The examples' run() and the benchmarks take a held composer — the planning examples' run() takes a keyword-only composer=; test_planning_benchmarks and test_parallel_scaling hold one composer per module and build the robot outside the timed call, so they time planning, not the plugin load. Re-measured without the load, a solve takes about 85 ms and more OMPL planners make it slower (8 planners: 1.6× in first-solution mode); the old table's "4 planners 1.58× faster" was plugin load, and run_scaling_benchmarks.sh no longer prints that conclusion regardless of the data (#137).
  • The planning guide's performance tips hold the composer — "Pre-Load Plugins" warmed a composer it never passed to plan_*, and "Profile Caching" cached profiles while every call still loaded the plugins; both now hold one composer and pass it (#137).
  • TaskComposer.get_available_pipelines() reads the factory; !include configs work — the method re-parsed the config file with PyYAML, which does not know the !include tag, so any config using it raised yaml.constructor.ConstructorError. It now takes the node names from the factory, which expanded !include when it loaded the config, and composer.py no longer imports yaml. TaskComposerPluginFactory.getTaskComposerNodePlugins() (dict[str, PluginInfo], a copy) and getAvailableTaskComposerNodePlugins() (the node factory class names the plugin libraries export, such as PipelineTaskFactory; not the configured names) are bound; the second loads the plugin libraries, so it pins them like createTaskComposerNode does (GH #48). A TaskComposer built without config_path now lists the factory's pipelines instead of []; config_path is informational (#185).
  • TaskComposerPluginFactory accepts any ResourceLocator — the constructor and createTaskComposerPluginFactory raised TypeError: locator must be a GeneralResourceLocator for every other locator, including Python ResourceLocator subclasses, so a model locator could not be kept apart from the installation one. Both now bind the ResourceLocator base, as the C++ constructor does (#150).

Python surface, errors and lifetimes

  • spdlog sinks bound — Logger.sinks reads and replaces a logger's spdlog sinks, StderrSink is tesseract's default console sink, and PythonLoggingSink(name) writes each record to Python logging (level, source file, line and function on the LogRecord; text from the sink's spdlog pattern). Replacing the default logger's StderrSink with a PythonLoggingSink sends tesseract's output to Python once; a record handler alone sees each record while stderr still prints it. Sinks are C++-owned and Python holds a share, so a logger keeping one keeps no Python object alive. Logger.set_pattern() and Logger.flush() are bound too.
  • Logging test no longer leaks at exit — test_handler_exception_reaches_unraisablehook kept the hook's arguments, whose traceback frames held the test's own locals: a cycle that kept a LogRecord and the Logger alive past interpreter exit, which nanobind reported as leaked. It now keeps the exception's type and text.
  • Stubs accept names where ids are taken — parameters typed LinkId / JointId are stubbed LinkId | str / JointId | str and LinkIdPair params accept tuple[str, str], matching the implicit conversions; return types stay exact. (#141).
  • Batched transform stacks: Environment.link_transforms_batch, Isometry3d.compose_each, apply_directions_each — one call where a consumer looped in Python over states or transforms. link_transforms_batch(joint_names, joint_values, link_names) takes (M, N) joint states and returns the (M, L, 4, 4) world transforms of link_names; row m is bitwise getState(joint_names, joint_values[m]).link_transforms[link].matrix, and the environment's state is not moved. iso.compose_each(stack) returns iso * Isometry3d(stack[i]) for each transform of an (M, 4, 4) stack; apply_directions_each(stack, vectors) rotates row i of an (M, 3) array by transform i, bitwise Isometry3d(stack[i]).apply_directions. Unknown joint or link names, a column count that is not len(joint_names) and a row-count mismatch raise ValueError. At 20 000 iiwa states and 8 links, link_transforms_batch takes 0.049 s against 0.264 s for the getState loop it replaces (osx-arm64, measured).
  • nearest_rotation and NonFiniteMatrixError — nearest_rotation(M) returns the rotation closest to a 3x3 matrix in the Frobenius norm, U·diag(1, 1, det(U·Vᵀ))·Vᵀ from Eigen's JacobiSVD, so a consumer projecting noisy rotations onto SO(3) does not need a numpy SVD beside the binding's Eigen types. det is +1 for every input, a reflection included. Not bitwise idempotent: an exact rotation returns within 5.5 ε (measured, osx-arm64). A NaN or infinity raises NonFiniteMatrixError(ValueError). Rank < 2 input has no unique minimiser and returns one of them unchecked.
  • Rigidity readouts: orthonormality_residual, determinant and their stack forms orthonormality_residual_each, rotation_determinant_each, plus norm_each — the checks a consumer runs to accept a matrix as a rotation, in Eigen, so it needs no numpy linear algebra beside the binding's types. orthonormality_residual(R) is max|RᵀR − I| of a 3x3 and determinant(R) its determinant; the _each forms read the rotation block of each transform of an (M, 4, 4) stack and return (M,), row i bitwise the scalar call on stack[i, :3, :3]; norm_each(vectors) is the norm of each row of an (N, 3) array. Within 8 ε of numpy's abs(R.T @ R - I).max(), linalg.det and linalg.norm. A shape other than 3x3, (M, 4, 4) or (N, 3) raises TypeError.
  • Isometry3d.precompose_each — iso.precompose_each(stack) returns Isometry3d(stack[i]) * iso for each transform of an (M, 4, 4) stack, row i bitwise the single product: compose_each with iso on the right, so a consumer moving many poses by one fixed pose in their own frames (a tool-axis hop) makes one call instead of one compose per pose. At 2 000 rows out of a 200 000-pose stack it takes 0.74 ms against 3.4 ms for the per-pose numpy update it replaces (osx-arm64, measured).
  • Eigen arguments accept lists and tuples — nanobind's Eigen caster imports an argument through DLPack or the buffer protocol only, so every Vector3d, VectorXd, Matrix3d or Matrix4d parameter raised TypeError for a list or tuple: Isometry3d.Identity().translate([1, 2, 3]), Isometry3d([x, y, z], q), env.setState(names, [..]), JointWaypoint(names, [..]), even the vector overload of Quaterniond.from_rpy([r, p, y]). One caster in tesseract_nb.h, seen by all 23 modules, wraps nanobind's: when nanobind refuses an argument and implicit conversion is allowed, it runs a sequence through numpy.asarray and asks nanobind again, so shape, dtype and layout checks are nanobind's. A wrong shape ([1, 2] for a Vector3d) still raises TypeError and nothing is padded or truncated; integers convert to float64; strings, None, complex numbers and ragged nesting raise TypeError, and an integer parameter (mesh faces) refuses floats. Parameters a function writes into (jacobianChangeBase, jacobianChangeRefPoint, twistChangeBase, twistChangeRefPoint, applyTolerances, harmonizeTowardZero, harmonizeTowardMedian) still take only a matching array. The stubs annotate an Eigen parameter as NDArray | Sequence[float] (Sequence[Sequence[float]] for a matrix), the in-place ones as NDArray alone; return annotations are unchanged.
  • A Python exception keeps its type across extension modules — a Python ConstraintSet whose getValues raised IndexError reached the caller of TrustRegionSQPSolver.solve, init, TrajOptQPProblem.convexify or getExactCosts as RuntimeError on macOS, with the traceback as its message. Each extension links nanobind statically and so carries its own typeinfo for nanobind::python_error; macOS libc++ compares typeinfo by pointer, so _trajopt_sqp did not recognise the error thrown by _trajopt_ifopt's trampoline. Every module that defines a trampoline (tesseract_common, tesseract_collision, trajopt_ifopt, trajopt_sqp, tesseract_motion_planners_descartes) now registers a translator that restores the Python exception (#156).
  • A None in a list of objects raises TypeError instead of crashing — nanobind rejects None for a direct object argument, but turns a None element of a list into a null pointer, which upstream dereferences later. CombinedContactAllowedValidator([None], …) segfaulted on its first call, addCollisionObject(name, mask, [box, None], poses) on either contact manager and the JointVelConstraint / JointAccelConstraint / JointJerkConstraint constructors segfaulted at once, and CompoundMesh([None, None]) stored null meshes. Each now raises TypeError naming the argument and index ("addCollisionObject: shapes[1] is None, expected a Geometry"), through one shared check that Environment.applyCommands / init(commands) already used (#201).
  • Isometry3d.apply_points and apply_directions: a batched apply — iso.apply_points(points) maps an (N, 3) float64 array in one call, where a Python loop over iso * p was the only way: about 126× slower than numpy at 2 000 points (osx-arm64, 0.35.0.8). Row i equals iso * points[i] bit for bit, because each row runs the same fixed-size Eigen product; a dynamic 3 × N product vectorises and fuses differently and came out up to 4e-16 apart. apply_directions applies the rotation only, as iso * v would with the translation zeroed. Both take N = 0 and strided views without a copy, convert Fortran-ordered and non-float64 input, and return a new array; a (3,) array raises TypeError (a single point stays iso * p). On osx-arm64 a call costs about 1 µs up to 24 points and 3.2 µs at 2 000, against 1.3–1.6 µs and 16.7 µs for numpy's p @ R.T + t. The Isometry3d docs said translation(), rotation() and matrix() were methods: they are read-only properties.
  • applyCommand releases the GIL for the two commands that carry geometry — adding a link whose collision geometry is a mesh spends seconds inside Environment::applyCommand building collision shapes, all of it holding the GIL, so every other Python thread stalled on what is pure C++ work. applyCommand(AddLinkCommand) and applyCommand(AddSceneGraphCommand) now drop the GIL around the C++ call, matching the solve() / contactTest guards, as do getDiscreteContactManager / getContinuousContactManager — applyCommand only updates a contact manager that is already cached, so with a cold cache the shape build lands in the first getter call instead. EventCallbackFn now re-acquires the GIL, since the environment fires event callbacks from inside that released region (and from C++ threads such as the ROS 2 monitor). Known ceiling: a registered Python event callback plus a concurrent Python thread calling a non-releasing Environment method can deadlock, because upstream fires event callbacks under the environment's unique lock.
  • Environment.clone() releases the GIL — cloning a large environment held the GIL for the whole native deep copy, so a worker cloning off the UI thread still froze it. Audited against tesseract 0.35.0: Environment::clone holds the environment's shared lock (serialised against setState / applyCommand), and the copy touches no Python state — event callbacks are not cloned, find_tcp_cb has no Python binding, and Python-owned resources are only shared_ptr-copied. A private _GilProbe, attached as a find-TCP callback that clone() copies, records whether each copy ran with the GIL, so the test checks the release directly instead of timing another thread; a timed version failed on loaded CI runners (#134).
  • Typing stubs match the bindings; CI fails on drift — the committed .pyi stubs had not been regenerated since the 0.35 namespace change: they still spelled tesseract_common::…, lacked ContinuousContactManager.getCollisionObjectGeometries / getCollisionObjectGeometriesTransforms (#157), and had no stub at all for tesseract_serialization. All stubs are regenerated. pixi run stubs regenerates them and pixi run stubs-check fails on any difference. Every CI build job runs the check, so a binding change without a regenerated stub no longer gets in. Stubgen output depends on the nanobind version, so nanobind is now pinned to exactly 2.12.0 (#159).
  • Four bindings that failed from Python now work — each showed up in the stubs as a quoted std:: C++ type, which also made the stubs differ between platforms:
  • TaskComposerFuture.waitFor raised TypeError on return; it now returns the new FutureStatus enum (ready / timeout / deferred).
  • Resource.getResourceContentStream raised TypeError too; it now returns the contents as an io.BytesIO.
  • Tesseract maps that use Eigen::aligned_allocator (e.g. TransformMap) had no Python conversion, because nanobind's unordered_map caster matches default-allocator maps only. They now convert to and from dict.
  • KinematicsPluginFactory found FilesystemPath only if tesseract_common had been imported first. Kinematics now imports it itself.

A test rejects any std:: type left in a stub (#159).

Viewer and demos

  • The online planning person walks the cell — a person to scale (1.75 m, segment ratios of stature) stands in the human e-stop cylinder and walks a scripted loop at 1.3 m/s, shared by both online examples (online_planning_scene), as the C++ example's human does. online_planning_sqp_example.run() takes up to SQP_STEPS_PER_TICK (10) steps per 0.1 s tick; sqp_steps_per_tick=1 is the C++ loop's single step. The clearance example is recorded (its labels laid out in the recording's view), and the TWC workcell clip is one 5 s rail period.
  • The README's poster opens the docs player, not the bare client — it links the docs home with #play, and demos.js starts a page's first player when the URL carries that hash.
  • The live viewer looks like the docs' demo players — dark theme without viser's logo, a floor grid (/floor) under the scene's footprint laid by update_environment, and orange as plot_trajectory's default path colour (was white). The demo recorder shares the floor and colour constants from tesseract_robotics.viewer.floor and viewer.PLOT_COLOR_RGB.
  • The README and docs show the examples running (#379) — the README opens on a car_seat poster that links to the live viewer, and the docs home and example pages embed players that load on click. They play, scrub and orbit from static files, with no Python server. Examples moves up to directly after Installation, and the README's Development section moves to the developer guide.
  • TesseractViewer.record writes a .viser file (#379) — record(phases, *, fps=30.0) returns the scene playing a sequence of RecordingPhase(env, trajectory), through a public API. RecordingFpsError names a bad fps.
  • Demo tooling (#379) — demo-record, demo-posters, demo-players, demo-check, demo-fetch and demo-check-site. Recordings live in the demo-assets release under their hashes, pinned by scripts/demos/demos.lock.json, so they stay out of git history. The Docs workflow fetches and verifies them, and fails when the built site references a file it lacks.
  • TesseractViewer.close() shuts the server down — it called a _TesseractViewerAIOServer.close() that did not exist, printed the AttributeError and went on, leaving the port bound and the event loop open. The server now closes its websockets and connections and releases the port; close() closes the event loop, is idempotent, and raises instead of printing. aiohttp's shutdown only closes connections it has registered, and asyncio drops a connection accepted just before the listener closes (Server._attach asserts the server is open; the accepted socket leaks in CLOSE_WAIT), so the viewer owns its asyncio.Server and force-closes every connection it accepted. start_serve_background() now returns once the port is listening, not before, and bind errors reach the caller; serve_forever() called a misspelled method and failed at once (#150).

Examples, tests and tooling

  • ty is the type checker of record — pixi run typecheck runs ty and reports 0 diagnostics for the whole package, examples included; the pre-push hook and CI (Linux x86_64, against the built wheel) run it, and pyright and pyrightconfig.json are gone. Example require_success accepts any result with read-only successful / message; examples raise ResourceNotFoundError when a package:// URL does not resolve.
  • Reload-gate tests wait on the gate — the private probe _reload_gate_waiters(server) counts the calls blocked on a running reload, so the deadlock tests wait (with a deadline) until the overlap happened instead of sleeping to widen the window; the graph test's future.ready() poll has a deadline (#370).
  • The low-level examples use the bindings only — the nine examples/lowlevel files that imported tesseract_robotics.planning build their environment, programs, profiles and task composer runs from the binding types, as their C++ originals do; lowlevel/example_support.py holds the plumbing the C++ examples share (example.cpp). The C++ ports now use the C++ parameters where they had drifted: freespace_ompl runs OMPLPipeline with two RRTConnect planners (range 0.01, 60 s), glass_upright holds orientation with coeff 1 (was 5), pick_and_place uses the C++ box (0.2 m at (0.15, 0.4)) and post-check profile, and the TrajOpt examples take ifopt=True for the TrajOptIfoptPipeline branch. pythonic_c_api_example showed the high-level API, so it moved to examples/pythonic_api_example.py. tests/examples/test_lowlevel_bindings_only.py keeps planning out of lowlevel/ (#42).
  • Per-seed report of the clearance example — pixi run ompl-seed-report plans freespace_clearance_objective_example.py's two cases once per seed (N = 10, one process each) and writes a JSON and Markdown table of the OMPL stage (wall time, smallest cube clearance) and the TrajOptIfopt stage (SQP iterations, status, final clearance and joint-space length). It plans with FreespaceIfoptOMPLOutputPipeline (scripts/ompl_seed_report_task_composer.yaml), stock FreespaceIfoptPipeline with the OMPL program handed to TrajOptIfopt under its own key, so one run yields both paths; a test checks its final program is bit-identical to stock's on a fixed seed. The example gains run_case(), which run() and the report share. PlanningResult gains task_infos (the run's node infos: name, status message, elapsed time) and data_storage (the run's data storage, with each nested pipeline's own storage under its uuid) (#362).
  • Standard toolpaths — planning.toolpaths.zigzag_square() (the RAPID golden test's square outline and zigzag fill, lifted unchanged) and planning.toolpaths.circle(radius_m, n_waypoints, center=, z_m=) (tool down, the #140 contours) return list[Pose] for tests, docs and benchmarks; tests/conftest.py serves the square as zigzag_square_poses. The square's orientation is 180° about Z, not tool down; the golden locks it (docs/user-guide/planning.md) (#84).
  • The puzzle aux-axes example runs on TrajOptIfoptPipeline — run(pipeline="TrajOptIfoptPipeline") uses the new create_ifopt_profiles(), the if (ifopt_) branch of the C++ example (OSQP adaptive_rho left at its default, as upstream). The legacy ports set adaptive_rho = 0 as the C++ legacy branch does, and the low-level port's profiles come from create_profiles(). docs/developer/trajopt-collision-memory.md records why both TrajOpt planners peak at 3.2 GiB on this example (one contact-manager clone per waypoint) and the upstream fix for ifopt (tesseract_planning#787): 437 → 1 clone, 28× lower peak, bitwise-identical trajectory.
  • car_seat runs on TrajOptIfoptPipeline, and freespace_hybrid's ifopt run uses the C++ profiles — car_seat_example.run(pipeline="TrajOptIfoptPipeline") uses the new create_car_seat_ifopt_profiles(), the C++ if (ifopt_) branch (LVS_CONTINUOUS cost and constraint). freespace_hybrid_example.run(use_ifopt=True) registered no ifopt composite profile and planned with the planner defaults. The new add_ifopt_profiles() adds the C++ composite: cost and constraint TrajOptCollisionConfig(0.025, 20), smoothing coeffs of 1. With the #787 fix, car_seat clones 40 → 4 contact managers and its trajectories stay bitwise identical.
  • python_constraints_example: the seven rules in one live loop — an IRB 2400 on its rail with a tool on the flange, one single-waypoint solve per frame, the rules switched on one after another and all at once. tesseract_python_constraints_example plays the acts; --sliders hands the rail, the ball, the mark (a handle to drag) and every rule's bound to the viewer, and handing the rail to the solver switches on CarriageFollows, an eighth rule written in the example, which keeps the carriage abeam of the tip. Captions, a gauge per rule, the solve time against the 30 Hz frame and the rules' glyphs are links of the environment, so a recording carries them. Its recording plays on docs/examples/python-constraints.md.
  • from_yaml examples for every planner — docs/user-guide/planning.md gains "Profiles from YAML": one checked example each for the simple, OMPL, TrajOpt, TrajOpt-Ifopt and task-composer planning profiles, with the merge-versus-replace rule for nested configs (#331).
  • Low-level SQP guide: why the online example rebuilds its problem, starting values, failure — the guide said the obstacle pose is "baked into" the collision constraints, untested. Measured: a problem built before env.setState moves the obstacle keeps a summed collision violation of 0.0 where a rebuilt one has 1.92, and perturbing the variables does not change that, so each evaluator's contact manager fixes the pose at construction, not its cache. Upstream's example rebuilds every tick too. New section: upstream's coefficients for the example and how to read SQPStatus and the remaining constraint violation (#12).
  • The getting-started pages run, and a test runs them — nothing executed them, and none of their plans could succeed: the quickstart and index targets were unreachable for the IRB2400, the README loaded package://tesseract_support/ (removed in tesseract 0.35) and its own box blocked the goal, concepts.md called methods removed since 0.33 and tcp_pose.position, which does not exist. Targets now come from upstream's freespace_example.cpp (the README drops the obstacle upstream does not have). tests/docs/test_getting_started_snippets.py runs every page's Python blocks in order, one process per page; a block is skipped only behind a visible <!-- snippet: skip --> marker (placeholder paths, the viewer, which binds port 8000), and every plan asserts success (#137).
  • Named TCPs: the composition contract documented and a parsed-SRDF roundtrip tested — group_tcps was readable since #133's read path landed, but nothing said how a named TCP composes or parsed one from an SRDF. A test parses an SRDF with three TCPs in one group and two in another (one name in both, with different transforms), reads each back exactly through SRDFModel.kinematics_information.group_tcps and Environment.getKinematicsInformation(), and resolves each with findTCPOffset. The API pages document the rule from the tesseract 0.35.0 sources: findTCPOffset's resolution order, the TCP pose T(tcp_frame) * offset, Cartesian targets relative to working_frame, IK on C * offset⁻¹, getCombined taking tcp_offset only with tcp_frame, the SRDF's scalar-first wxyz, and saveToFile writing TCPs at 6 significant digits (#133).
  • Kinematics examples for the new kinematics API — a new docs page, Kinematics Examples, and its examples, each a console script that returns its results for the test to assert on. kinematics_plugins_example builds IIWA kinematics from the plugin YAML with KinematicsPluginFactory(Path, locator), creates solvers by group name and by PluginInfo, switches the default inverse solver from KDL LMA to NR on upstream's runInvKinIIWATest problem (checking each solution with the solver's own stopping rule), adds, sets as default and removes a solver as upstream's PluginFactorAPIUnit does, round-trips saveConfig, and solves through a KinematicGroup built without an Environment. kinematics_analysis_example ports upstream's runJacobianTest: every native calcJacobian overload and the re-based ForwardKinematics Jacobian against all three numericalJacobian overloads, within a tolerance derived from the forward-difference step (δ = 1e-8: truncation plus rounding, 3.5e-6; measured 6.6e-8). It then shows calcManipulability and isNearSingularity at upstream's q and at the singular q = 0 (rank 5, three identical columns), the harmonizers, isValid, checkKinematics, KinematicLimits with isWithinLimits / enforceLimits, and the pose-error and tolerance-band functions on upstream's unit-test values. state_solver_example ports upstream's floating-joint test: OFKTStateSolver.replaceJoint makes the IIWA's joint_a1 FLOATING at x = 1.25 m, then the floating value moves to y = 1.5 m and z = 1.5 m. Every native setState, getState, getJacobian and getLinkTransforms overload runs with floating_joint_values, checked against a KDLStateSolver rebuilt from the scene graph after each change. insertSceneGraph attaches upstream's sub-graph through a FIXED joint, and again with a prefix through a FLOATING joint.
  • Collision examples for the new collision API — a new docs page, Collision Examples, and its examples, each a console script that returns its results for the test to assert on. contact_managers_example ports upstream's box_box_example.cpp to all three discrete backends, built by name from ContactManagersPluginFactory(Path, locator). The backends agree on the colliding pair but not on penetration depth: FCL reports the analytic 1.3 m, Bullet 1.266 m on the box_2m.ply hull. At x = 1.6 the gap is one ulp above the 0.1 margin, so nothing is reported, as upstream's unit test expects. The example then runs upstream's pair-margin cases through the CollisionMarginData / CollisionMarginPairData constructors, incrementMargins, scaleMargins and apply, each checked by a contact test. It edits the factory as upstream's PluginFactorAPIUnit does, round-trips saveConfig, and builds upstream's TestGetAllowedCollisions ACM from a dict. A Python ContactResultValidator drops one contact pair, and the ContactResultMap is iterated and edited. A cast manager runs through the three sweep overloads of setCollisionObjectsTransform, reproducing upstream's cast-unit cc_transform and nearest_points_local points. On the IIWA environment it uses EnvironmentContactAllowedValidator, managers by name and the SetActive*ContactManagerCommand pair. trajectory_collision_example runs both checkTrajectoryState overloads and checkTrajectorySegment on upstream's boxbot boxes, 0.1 m in collision. FCL reports the analytic depth; Bullet reports 0.0577 m on these face-aligned boxes. It then rebuilds checkTrajectory's LVS_CONTINUOUS result on upstream's IIWA-and-sphere trajectory from checkTrajectorySegment and addInterpolatedCollisionResults. Each step equals checkTrajectory's, with upstream's 288 contacts. Equality needs one reused ContactResultMap, because clear() keeps its keys. Last, it builds a JointTrajectory with both constructors and applies AddTrajectoryLinkCommand with each Method: 14, 2, 7 and 1 collision shapes, as each method's semantics predict. convex_decomposition_example ports upstream's create_convex_decomposition tool, with its options, ranges and VHACDParameters defaults as argparse, plus a --fill_mode option. It splits the car-seat mesh into 64 V-HACD hulls, checks each against its own faces with an orient3d plane test (and, for the flat hulls V-HACD can return, an orient2d polygon test), and writes them as PLY files that read back to their written precision now that hull faces are repaired (#233). Each FillMode gives its own decomposition. A second createConvexHull of a hull's vertices is convex and keeps only those vertices, but it is not idempotent: Bullet merges a vertex within one step of its integer grid, and one RAYCAST_FILL hull loses a vertex 4 µm above a face.
  • Environment examples for the new environment API — a new docs page, Environment Examples, and its examples, each a console script that returns its results for the test to assert on. environment_commands_example builds ABB IRB2400 environments with init(Path, Path, locator) and init(Path, locator) from GeneralResourceLocators made by each constructor, loadEnvironmentVariable and addPath, and checks getCommandHistory() against upstream's getInitCommands. An SRDF read with initString, carrying upstream's unit-test calibration as a fixture, adds one ChangeJointOrigin per calibrated joint; CalibrationInfo and SRDFModel.contact_managers_plugin_info are read back. On a URDF-only environment, AddContactManagersPluginInfoCommand makes the discrete manager available, applyCommands applies the calibration as one batch, and an event callback receives one CommandAppliedEvent per call. init(commands) replays a history: the histories, revisions and states are equal, the environments are not, because Environment == compares timestamps; a clone() is equal until a command is applied to it. The example spells out upstream's SceneState == comparison, which == now binds (#232). Last, BytesResource from bytes and from a list of byte values, whose parent locator resolves a relative url next to it. environment_state_example makes the IIWA's joint_a1 FLOATING with a ReplaceJointCommand and moves it through upstream's floating-joint origins, one setState overload per step; the three getState and three getLinkTransforms overloads compute states without setting them. It reads joint values by name, the links given joints move, a JointGroup over given joints, getJointLimits, the link visibility and collision flags, the revisions, and the two timestamps, which setState sets from one clock reading. findTCPOffset resolves an explicit pose, the SRDF's laser and welder group TCPs, and, after addFindTCPOffsetCallback, upstream's callback TCP; a link name or an unknown name raises RuntimeError. ManipulatorInfo's full constructor, empty and getCombined follow upstream's unit test. plugin_configuration_example builds contact_manager_plugins.yaml in Python as a Bullet part and an FCL part merged with insert; the result equals what the IIWA SRDF loads, and applied with AddContactManagersPluginInfoCommand to a URDF-only environment it creates each manager by name. ProfilesPluginInfo (upstream's unit-test values) and TaskComposerPluginInfo (the shipped config's libraries, executor and two pipelines) show the merge and empty / clear; no Python constructor consumes those two yet. TaskComposerPluginFactory.getTaskComposerNodePlugins() and getAvailableTaskComposerNodePlugins() show that every configured class is available and that get_available_pipelines() lists only configured names.
  • Mesh round-trip example for the new geometry API — a new docs page, Geometry Examples, and mesh_roundtrip_example, a console script that returns its results for the test to assert on. It loads upstream's box_2m.ply from bytes with createMeshFromBytes (the binding's triangulate=True default gives 12 triangles), createSDFMeshFromBytes and createConvexMeshFromBytes (triangulate=False keeps the 6 quads) (#210). tesseract_material_mesh.glb goes through each create*MeshFromPath and create*MeshFromResource loader with normals, vertex_colors and material_and_texture on, giving upstream's four meshes with normals and one textured quad (#226). That quad is rebuilt through both overloads of each full Mesh, SDFMesh, PolygonMesh and ConvexMesh constructor with a MeshTexture (#207). Mesh == compares UUIDs, so the rebuilt pair is unequal until setUUID (#206); ConvexMesh.CreationMethod changes ConvexMesh == (#208). writeMeshToFile (#220) writes PLY, and createMeshFromPath reads it back within its seven-decimal precision. The reader joins identical vertices, so a mesh with one vertex per normal comes back with one vertex per distinct position. Isometry3d.apply_points / apply_directions equal tf * p row by row, and PointCloud.Point (#209) fills a PointCloud for createOctree. The Basic Examples tip for loading meshes called a Mesh.fromFile that was never bound; it now uses createMeshFromPath. Wheels now ship the support mesh tesseract_material_mesh.glb: the support-data install rule copied files by an extension list that had no *.glb.
  • scene_graph_example builds a scene graph directly — a second, low-level part builds upstream's five-link test graph with SceneGraph, Link and Joint (one joint per JointType member, #214), and checks it against upstream's unit tests: adjacent links, children, getAdjacencyMap, isAcyclic / isTree through a disconnected link and a second parent, and the str() of JointType, the joint value types and a ShortestPath, each upstream's operator<< (#215). setAllowedCollisionMatrix replaces the matrix and the graph keeps the object; Link.visible / collision_enabled are the flags setLinkVisibility / setLinkCollisionEnabled set (#216). The example had no test; it now has one.
  • Online SQP example: continuous mode works; collisions set up as in the C++ reference — build_optimization_problem(..., use_continuous_collision=True), which is also its default, raised RuntimeError: LVSDiscreteCollisionEvaluator, should be configured with LVS_DISCRETE, because the example never set the collision check type. online_planning_example.cpp sets DISCRETE for both modes, so its continuous mode throws the same way. The example now sets LVS_DISCRETE there. As the C++ reference does, it also sizes every collision set by the config's max_num_cnt (3; it passed 1), requests all contacts, and fixes the start of the first continuous segment. Its contract tests now run in both modes.
  • Docs follow the new problem — the replanning rates are re-measured on the TrajOptQPProblem example: about 70 Hz discrete and 20 Hz LVS continuous, on an Apple M1 Max. The 128 Hz "no collision" row is gone, because the example has no such mode. The trajopt_ifopt reference now lists, for each constraint class, its row bounds and the penalty types TrajOptQPProblem accepts it with (measured). It also gives the collision check type each evaluator requires; the constructors raise otherwise, and the online-planning page's continuous snippet used to miss it. The developer page on the constraint bindings, last current in 0.33, is rewritten.
  • create_descartes_default_profiles documents the real sample_max default — the docstring said +pi; the library default is pi/2, pi minus the default sampling resolution, so -pi and +pi are not both sampled. A caller who changes sample_resolution sets sample_max with it.
  • Planning API — Robot.ik returns an ndarray (a list with all_solutions=True); the Pose factories take the array or the scalar form; Robot.build(env) validates the environment; TaskComposer.plan_* take pipeline=; default profiles come from a table covering every shipped pipeline.

Documentation

  • Documentation reorganised — Getting started, Concepts (frames and poses, Python and C++ conventions, glossary), User guide, Examples, API reference, Release notes and Developer. The docs home and README open with one runnable ABB IRB 2400 example that plans and plays in the viewer (a test keeps the two copies identical); the examples page is a gallery of every recorded demo; the collision guide and the motion planning guide gain explanations, figures and a planner decision diagram; API reference pages share one layout and gain time_parameterization, task_composer_planning, motion_planners_trajopt_ifopt, viewer, emitters and build_identity; the emitters page moved to the user guide; ASCII diagrams are Mermaid; the theme has light, dark and system schemes. The snippet test covers every python fence of the README and the user-facing pages. Claims the docs could not back (collision-free DISCRETE results, guaranteed OMPL solutions, real-time rates, serialization speed-ups) and the duplicate docs/QUICKSTART.md are gone.
  • Docs figures generated from the library — pixi run docs-figures draws frames and TCP offset, contact distance and margin, discrete vs LVS vs continuous collision, TOTG, a planned raster toolpath, IK branches and a measured OMPL / TrajOpt / TrajOptIfopt comparison, in light and dark. pixi run docs-figures-check fails unless regenerating them matches the committed SVGs and docs/assets/figures/figures.lock.json bit for bit; pixi run docs-figures-measure NAME re-runs a measured figure's benchmark.

Binding audit

  • The binding audit report names the upstream commits it parsed — its header read the conda tesseract-robotics pin, which the single native build removed, so every main run failed with KeyError. It now names the tesseract, tesseract_planning and trajopt versions dependencies.rosinstall pins (a commit SHA shortened to 8 characters), and raises UpstreamPinError when one is missing.
  • The binding audit lists the repo's include dirs again under CI's layout — CI sets AUDIT_NATIVE_ROOT to the workspace, which also holds the repo checkout, and the fact cache left out every dir under that root, so no repo include dir was listed. Only the stack's own ws/ and vcpkg/ are left out now. The native-stack lookup moved from audit_parse to audit_native, which also brings audit_parse back under the audit's 1k-line cap.
  • The binding audit finds the native stack's vcpkg prefix by its recorded triplet — vcpkg/installed holds the host triplet's build tools (x64-linux) beside the target (x64-linux-dynamic-release), so the audit's "exactly one triplet" check failed every main run on the native stack. audit_parse.native_include_roots now reads the triplet from the identity file scripts/native_stack.py writes after its vcpkg stage, and raises NativeStackMissingError when that file is absent.
  • The binding audit reports trailing defaulted parameters Python cannot pass — a C++ overload with defaulted parameters counts as covered only if a covering Python overload accepts all of them; otherwise the gap names the unreachable ones. OFKTStateSolver(scene_graph, prefix) is accepted under upstream-broken-default (#251, tesseract#1384).
  • The binding audit report names a stub row by its file, not its line — a stub edit that only moves lines no longer makes CI's "Report is current" step fail; the report changes only when a row is added, removed or reclassified. Header rows keep their line, and the JSON report keeps every line. docs/developer/binding-audit-coverage.md lists when the report needs regenerating.
  • The binding audit states its coverage — the report names every binding module it does not audit, with the reason; a binding module in neither table fails the run. Header ownership supports several prefixes per module and nested prefixes; the planning and trajopt bindings now parse (#256).
  • The binding audit reads what each nb::class_ binds — classes are identified by their qualified C++ name, read from the binding's nb::class_/nb::enum_ calls. A class bound under another Python name keeps its members audited, and two C++ classes with the same leaf name are no longer confused across modules. Members inherited from an unbound base are audited, and a stub class that is missing its bound C++ base is reported. The audit scripts are split into one file per job (audit_ownership, audit_types, audit_parse, audit_stub, audit_rules, audit_match, audit_report, plus the audit_bindings CLI); this does not change the report (#256).
  • The binding audit covers tesseract_command_language and tesseract_time_parameterization — type-erased Polys, their alternatives and their template casts are matched to their bindings. A single overload can now be accepted by rule. Not-API header patterns are scoped to the module that owns the prefix (#256).
  • The binding audit covers trajopt_ifopt and trajopt_sqp — trajopt's kCamelCase enumerators are matched to their UPPER_SNAKE bindings, and compound-assignment operators to __iadd__/__isub__. Members typed by OsqpEigen are accepted as having no Python form (#256).
  • The binding audit covers the motion planners — all six planner modules, including classic TrajOpt (trajopt_sco/, trajopt/) and descartes_light/ through the planners that use them. The yaml-node rule now requires a bound path or YAML-text sibling, or a static from_yaml(text) on the class, so YAML constructors without one are reported. Members typed by OMPL, or by a type declared only in a not-API header, are accepted as having no Python form; a type that some module binds never is. operator= is no longer reported, and a class template's constructor template counts as a constructor (#256).
  • The binding audit covers the task composer — tesseract_task_composer and tesseract_task_composer_planning. Forwarding constructor templates (AnyPoly_wrap_*) count as template instances, and built-in task nodes are not API. The plugin-author factory interfaces are accepted by one rule, which also covers core's FwdKinFactory, InvKinFactory and contact-manager factories. An exception registered with nb::exception under a Python name is bound, and upstream's Python-only addNodePython/addTaskPython (bound as addNode/addTask) and TaskComposerNodePorts.__str__ are accepted. Only ompl_base stays unaudited, pending its removal (#258) (#256).
  • Every open audit row has a recorded outcome — scripts/audit_ledger.json maps each open gap, deviation and quoted name to an issue (#NNN) or a won't-fix reason, and the report shows it in a new issue column. tests/audit/test_audit_ledger.py fails on an open row with no outcome and on an entry whose row has gone, so a fixing PR removes its own entries (#256).
  • The binding audit pairs a parameter typed by a class another module renames — checkPIQPSettings(const piqp::Settings<double>&, …) in tesseract_motion_planners was reported as a gap and a deviation, because piqp::Settings<double> is bound in trajopt_sqp as PIQPSettings and the audit unaliased only the classes the module itself renames. Parameter keys now unalias every class a binding module binds under another name, when the C++ side keys it by its leaf name (not Eigen or std classes, converted records, id templates, or a binding's own wrappers); a Python name two modules bind as different classes stays unpaired (#373).
  • One full binding audit per CI run — .github/workflows/audit.yml runs the full audit last, once, for the ledger test and the check that the committed report is current. It runs on main, on tags and by hand, not on pull requests, so nothing is enforced before merge: a PR's unledgered rows or stale report show up on main after it lands. The ledger test now names missing and stale entries in one failure (#373).
  • The binding audit matches overloads by parameter type — a C++ overload counted as bound when any Python overload of the same name took as many arguments, so SceneGraph.getJointChildrenNames(const std::vector<std::string>&) hid behind the bound getJointChildrenNames(str). scripts/audit_types.py now maps each C++ parameter type and each stub annotation to a key (std::vector<T> and Sequence[T], std::filesystem::path and str | os.PathLike, Eigen::VectorXd and NDArray[numpy.float64], a class and its subclasses, a container's typedef and its opaque bound name, …), and a Python overload covers a C++ one only where the keys agree. Overloads that differ only in const of this or &/&& of a parameter count as one. A type the mapping does not know (a template parameter, object) falls back to arity, and the report's new type fallbacks column counts those overloads. ContactResultMap.addInterpolatedCollisionResults is no longer misread as returning its in/out sub_segment_results. The 9 overloads the arity rule hid are bound or accepted: the plugin factories' YAML::Node constructors (rule yaml-node: the path and YAML-text overloads load the same config) and CompoundMesh's ConvexMesh/Mesh/SDFMesh list constructors (rule derived-element-container: upstream upcasts them into the PolygonMesh one, which Python already reaches with any subclass) are accepted; the rest are bound in the entries above (#247).
  • The binding audits read every translation unit of a split module — an extension module can now span several sources (audit_ownership.MODULE_PARTS: common_eigen, common_logging, environment_commands, task_composer_plugin_factory, task_composer_anypoly, trajopt_ifopt_collision), and the API and GIL audits read all of them; a source in src/bindings/ that is neither a module, a declared part nor a helper fails the audit. The GIL audit also names a released nb::init as __init__ and resolves a .def inside a function template whose receiver the caller passes at each call site.

Fixed

  • The online SQP example's warm start seeds the collision constraints — it wrote the last solution with NodesVariables.setVariables after setup(), so the collision constraints kept evaluating the straight interpolation and the solver reported convergence without moving while the person stood in the plan. The problem is now seeded when its variables are created (build_optimization_problem(initial_trajectory=...)), as the C++ example does.
  • A failed plan names the task that threw — a planner that throws reports status -1 and the nodes the abort passes through report "Aborted"; PlanningResult.message for a FreespacePipeline failure read ErrorTask: Aborted; ... with no cause and now names OMPLMotionPlannerTask and its error.
  • Local meshes resolve on Windows — mesh_from_file / convex_mesh_from_file build the resource of a local path or file:// URL from its filesystem path; GeneralResourceLocator turned file:///C:/... into /C:/....
  • A broken [support] install raises instead of reading as absent — get_tesseract_resource_path imported tesseract_robotics_support inside try/except ImportError, so an ImportError raised inside an installed support wheel looked like a missing extra and fell through to SupportDataNotFoundError. It now checks for the package with importlib.util.find_spec and imports it unguarded.
  • trajopt_ifopt.python_constraints imports — the module rename (#42) installed trajopt_ifopt as a bare extension, tesseract_robotics/trajopt_ifopt.<ext>, which shadows the trajopt_ifopt/ directory that holds python_constraints.py: every import of it, and of tesseract_robotics.examples, raised ModuleNotFoundError: 'tesseract_robotics.trajopt_ifopt' is not a package. trajopt_ifopt is a wrapped module again (trajopt_ifopt/_trajopt_ifopt plus a re-exporting __init__.py); import tesseract_robotics.trajopt_ifopt and its names are unchanged, and the stubs name the public path (tesseract_robotics.trajopt_ifopt.X).
  • calcManipulability's condition test follows the SVD formula — with tesseract#1396 condition is measure**2 from the singular values of J, which differs from the eigenvalue ratio by rounding (0.8 eps on Windows CI). The test checks condition == measure * measure exactly and the ratio to 3 eps.
  • A ContactResultVector element no longer outlives its storage — v[i] returned a reference into the vector that append (on reallocation), clear and ContactResultMap.flattenMoveResults(v) freed, so a held element read garbage and lost writes. v[i] is still a write-through reference (v[i].distance = d updates v), and while Python holds one those three calls raise ContactResultHeldError (a BufferError, as bytearray raises under an exported buffer) and leave v and the map unchanged. Delete the reference, or hold copy.copy(v[i]): ContactResult now has __copy__ / __deepcopy__ (#395).
  • PIQPSettings compares by value — == was identity, so equal settings compared False. PIQPSettings now has == / != from upstream's operator== (piqp/settings_utils.h: relative float-epsilon tolerance on the floating-point fields, exact on the rest) and __hash__ = None. It is bound in trajopt_sqp, which owns the type, from the header alone (no planner library linked), so the equality holds whatever else is imported (#393).
  • A shape from makeImplicitSDFShape keeps its geometry alive — an SDF shape referenced its SignedDistanceField without holding it, so once the field was dropped collideImplicitSDF could return no contacts with no error, and reading the shape's callables could crash. They now hold the geometry, and collideImplicitSDF solves on copies, so assigning a member during a call affects only later calls (#373).
  • A Python error in createOptimizationObjective keeps its type — it reached Python as RuntimeError holding the traceback text, because the OMPL module did not register the cross-module python_error translator; it now propagates as the original exception (#156, #362).
  • The clearance example's threshold case plans OMPL at the helpers' collision margin — case 2's LengthAndClearanceProfile is a fresh OMPLRealVectorMoveProfile, whose contact_manager_config.default_margin was unset, so its OMPL paths came within 0.0007 to 0.094 mm of the cubes while case 1 planned at 10 mm. Both cases now plan at planning.profiles.OMPL_CONTACT_MARGIN_M (0.01 m), the constant create_ompl_default_profiles uses, and differ only in the objective. The docs no longer claim the 4.0 rad threshold takes OMPL 1.1 to 1.5 s: in one run of 10 seeds on this pipeline OMPL met it in 0.04 to 0.07 s. With one planner its first path meets it on 4 of 5 seeds (pixi run ompl-first-path-probe) (#362).
  • Collision constraint getters before update() raise RuntimeError instead of crashing — getValues() / getJacobian() on the collision constraints (and calcValues() / calcJacobianBlock() on DiscreteCollisionNumericalConstraint) dereferenced a null pointer before the first update(). They now raise RuntimeError("<name>: collision data not computed, call update() first") (trajopt#617, carried as a patch) (#236).
  • Descartes profiles reach the shipped Cartesian and raster pipelines — the profile helpers registered only D profiles, which only DescartesDPipeline / DescartesDNPCPipeline read; CartesianPipeline, DescartesFPipeline and every raster pipeline ran the library defaults. They now register F and D from the same settings. Measured on tesseract_planning a648382: a move profile with a 10 m vertex margin, so every state collides, planned successfully through CartesianPipeline and DescartesFPipeline; all three pipelines now fail it with "Failed to build graph" (#350).
  • CartLineConstraint takes 1 to 6 indices — trajopt 0.35.0, which 0.35.0.8 and earlier bundle, sizes the Jacobian by len(indices) rows but fills 6, so getJacobian() with indices=[0, 1, 2] corrupted memory, in a direct call and in a solve. The pinned trajopt fills one row per index (trajopt#612): getJacobian() and calcJacobianBlock() with fewer than 6 CartLineInfo.indices return those rows of the 6-index Jacobian (#237).
  • A drag on the viewer's time slider is no longer lost to playback — viser applies a browser drag to the slider on its event loop, then runs the viewer's callback, which reads the slider back. The player checked the slider and then wrote its next frame from its own thread, so a drag that landed in between was overwritten and playback paused at the player's time, not the dragged one (Windows CI, test_browser_drag_pauses_and_scrubs). The player now checks and writes the slider on viser's event loop. If the loop does not run that write within VISER_LOOP_TIMEOUT_S (1 s), the write never happens, and playback pauses with ViserLoopTimeoutError logged.
  • macOS wheels load one OpenMP runtime, and repair without delocate — in a conda or pixi environment the wheel loaded a second libomp, so Descartes aborted with OMP: Error #15 or segfaulted above one thread. Images now look in the environment's lib first, then at the bundled copy, so uv and pip environments keep working. scripts/repair_macos_wheel.py replaces delocate-wheel, which took about 15 minutes of each macOS CI build, and rewrites RECORD, which missed 14 files and had 4 stale hashes. test-wheel runs in lean pixi envs and installs with uv, with no venv; pull requests test 3.12 and pushes to main and tags test every Python (#136, #377).
  • The TWC rail cell draws its rail (#380) — the example's load_urdf restores what the stale upstream URDF lacks: the rail mesh on rail_base_link and the 0.2 m joint origin from its xacro. The carriage now stays on the rail across the 10 m joint limit, which only the 12 m mesh holds.
  • Translucent materials render translucent in the viewer (#379) — glTF ignores alpha unless alphaMode is BLEND, so a URDF's 5 % estop zone drew solid and hid the robot inside it.
  • A server call no longer waits through back-to-back reloads — a call that waited for loadConfig, addTask or addExecutor woke up needing the GIL, which a thread reloading in a loop kept into its next reload, so the call could wait for as many reloads as the thread started. A reload now lets the calls already waiting go first, which bounds a call to the one reload it found running.
  • A Var or Node read out of a variable set keeps the set alive — Node.getVar / addVar, NodesVariables.getNode / getNodes and Var.getParent tie the result to its source, and a Node handed to NodesVariables keeps the set alive; var.getParent() after the set was dropped read freed memory (#297).
  • NodesVariables.getNode / getNodes return usable Nodes while the caller still holds the handed-over ones — they returned the caller's relinquished object, on which every method raised TypeError. A Node given twice, or one already in a set, raises NodeOwnershipError (a ValueError) and leaves every Node with the caller (#297).
  • Linking a constraint to a variable set that does not hold its Vars raises VarNotInVariableSetError — from linkWithVariables and from TrajOptQPProblem.addConstraintSet / addCostSet; a standalone Var or one from another set put the Jacobian's columns out of range (#297).
  • Node.getParent no longer reads a freed variable set — it returned a raw pointer to the Node's set, which a planner frees after its solve while a Python composite profile's create may still hold the Node. It now returns a set Python built (NodesVariables(...), createNodesVariables) only while that set is alive and holds the Node, and keeps it alive; otherwise it raises NodeParentUnavailableError (a RuntimeError). Linking a constraint checks that the set holds its Vars instead of comparing addresses, so a Var whose set was freed cannot pass for a member of a new set at the reused address. An unlinked collision constraint built on a Var kept from a planner's set raises the same error from update() instead of reading the freed set; one on a set built from Python updates as before. A Python subclass of NodesVariables is its own getParent() result, and NodesVariables(name, "...") with a str for nodes raises a clear TypeError (#297).
  • calcForwardNumJac raises NumericalJacobianSizeError (a ValueError) when f returns a different length at a perturbed x; trajopt read past the shorter vector (#295).
  • CartPosConstraint.calcJacobianBlock takes its joint count from its Var — it divided getNonZeros() by getRows(), and accepted any length with every axis weighted zero (#289).
  • A stored SQPCallback problem can't outlive the call — a problem with no Python object (one TrajOptIfoptMotionPlanner builds in C++) reaches a Python callback as a QPProblemView; once the call returns, every method on it raises QPProblemExpiredError (a RuntimeError). A callback that kept the problem used to read freed memory after solve() returned. A problem passed to solve() from Python still arrives as that object (#308).
  • InstructionsTrajectory(program) keeps program alive — it stores references into the program; built from a temporary (InstructionsTrajectory(make_program())) it read freed memory once the program was collected. It also holds references into the program's instruction vector, which appending, inserting or erasing instructions can reallocate: a later call returned stale values (5 appends), raised a RuntimeError (50) or crashed (20000). The binding now records the addresses of the program's move instructions and re-flattens the program before every method; on any difference it raises the new StaleTrajectoryError (a RuntimeError): build a new trajectory. setData still writes into the program. Cost per call: +0.3 µs on an 11-move program, +4.7 µs on 1000 moves. getPosition, getVelocity, getAcceleration, getTimeFromStart and setData raise IndexError for i outside [0, size()) (upstream indexes unchecked); negative i is rejected, not wrapped (#281).
  • TimeParameterization.compute names Environment in its signature — the stub said "tesseract::environment::Environment"; the module now imports tesseract_environment first (#277).
  • A task-composer run holds its node and executor until it ends — the executor runs the node in its own threads after run returns, but nothing on the Python side held the node, the data or the executor for that long: dropping the node before wait(), discarding the future (executor.run(node, storage) as a statement), keeping only a copy() of it, or dropping the executor mid-run freed them under the running task (a segfault, a wrong result or a hang). Every run overload of TaskComposerExecutor, TaskflowTaskComposerExecutor and TaskComposerServer now holds the node and the executor or server until the run ends, independent of the future; a server run also holds the executor it runs on, so addExecutor replacing it mid-run no longer deadlocks or destroys it under the run. A server's tasks cannot be held (upstream exposes them only as const&), so a server task is never replaced while a run or Python can reach it: TaskComposerServer.loadConfig, and addTask with an existing task's name, raise TaskComposerServerBusyError (a RuntimeError) while that task is the node of an unfinished run (by name, server.run(node) or any executor.run) or a getTask() result is still referenced, instead of freeing it under the run or the reference. Runs are registered before the GIL is released, so a reload on another thread sees them. While a server is inside loadConfig, addTask or addExecutor, other threads wait for it, Python log handlers included, and only calls from inside it raise the same error: a Python ResourceLocator during it (calling this server, or another server that is reloading too). A task added from Python (addTask) is owned by its Python object and never blocks replacement; a getTask() result in a reference cycle blocks it until gc.collect(). Releasing a future never blocks (also on an executor worker thread); a finished run is released once a future is seen done (wait, waitFor, ready) or at the next run, and runs still in flight at interpreter exit, including runs started meanwhile (also by a Python log handler), are waited for until their executor is idle (#315).
  • Windows: task-composer plugin DLLs stay loaded — a plugin factory (also a TaskComposerServer's) unloaded its plugin DLLs when Python freed it, but the results of a run (a future's context, its data and node infos) carry code from those DLLs, and Python frees them in any order: a future or context outliving the factory crashed at exit (access violation). The DLLs a factory or loadConfig loads are now pinned for the process lifetime, as the dylibs on macOS (#48).
  • TaskComposerNodeInfoContainer.prune / find callbacks — prune handed the callback a reference into the container, which dangled once the callback kept it and the container dropped the info; it now passes a copy and stores the edited copies when the callbacks return. Both called Python under the container's lock, so a callback that called back into the container deadlocked; they now call back on a snapshot, outside the lock. prune stores a changed copy only if the stored info is unchanged since the snapshot, and raises TaskComposerPruneConflictError (a RuntimeError) naming the infos changed or removed meanwhile (#320).
  • Environment command constructors take JointId / LinkId — eight constructors took std::string, so a JointId or LinkId from a 0.36 getter raised TypeError; they take ids, as the 0.36 headers do, and still accept a str. Their keywords are joint_id= / link_id= (were joint_name= / link_name=); MoveJointCommand keeps parent_link=, ChangeLinkVisibilityCommand visible= (#141).
  • Id-container fields read as copies — a list / dict of ids read from JointState.joint_ids, SceneState.joints / floating_joints, CalibrationInfo.joints, ContactTrajectoryResults.joint_ids, ContactManagerConfig.modify_object_enabled, ShortestPath.links / joints / active_joints or the four KinematicsInformation group maps referenced the C++ elements, which dangled once the owner replaced or cleared the field (13 fields). Editing the copy no longer writes through: assign the field (#141).
  • CollisionCoeffData.getPairsWithZeroCoeff() returns set[LinkIdPair] — 0.36 returns an unordered_set, which had no caster, so the call raised TypeError and the stub named a C++ type (#141).
  • Id-keyed Mapping parameters accept str keys in the stubs — a parameter typed Mapping[JointId, float] (or keyed by LinkId / LinkIdPair) is stubbed Mapping[JointId, float] | Mapping[str, float], so setState({"joint_a1": 0.0}) type-checks as it runs (#141).
  • A TaskComposerLog holding planner profiles round-trips on every platform — upstream registers the profile types in each planner's library on Linux and in the including translation unit on macOS and Windows, so saving raised RuntimeError on those two and loading on Linux needed that planner's library already in the process. tesseract_serialization now links the planners and registers their types; the Descartes, TrajOpt and TrajOptIfopt components are required at build time (#161).
  • Planning fixes — MotionProgram(profile=...) applies (a target without a profile inherits the program's; targets used to default to DEFAULT and always won); TaskComposer.plan seeds a copy of the caller's CompositeInstruction, not the original; warmup raises PipelineWarmupError for a pipeline that does not load; trajectory points carry time only where a time parameterization ran; mesh_from_file / convex_mesh_from_file resolve with pathlib, raise ResourceNotFoundError for a missing file and AmbiguousMeshError for several meshes; __version__ is the installed distribution's version, with no placeholder; the profile helpers name their margins, coefficients and planner defaults as constants and document the defaults the code uses. The plan_cartesian description no longer claims TrajOpt smoothing: DescartesDPipeline runs Descartes, a contact check and time parameterization.
  • Binding fixes — Descartes Python sampler and evaluator shims no longer touch the GIL after interpreter exit; urdf.writeURDFFile reports the whole nested cause and detects a file it could not write; Hyperplane3d / ParametrizedLine3d degeneracy checks are scale-free; Quaterniond.to_rpy switches to the gimbal-lock branch at cos(pitch) = sqrt(eps), where both are accurate to about 1.5e-8 rad; a TaskComposerServer's reload gate is freed with the server; class constants (CONFIG_KEY, SIN_ANGLE_FLOOR) render as values in the stubs; TrustRegionSQPSolver.stepSQPSolver() is documented as returning true when no further step should follow at the current penalty (converged step, spent QP failure budget or callback stop; getStatus() tells which).
  • Viewer fixes — record() restores the live poses when a phase fails; plot_trajectory holds the pose lock and update_environment clears plots; a close() timeout inside with no longer replaces the exception in flight; an unclosed viewer releases its port when collected or at exit; the floor sits at the scene's lowest point; Trajectory.from_rows raises TrajectoryShapeError for non-2-D input.
  • Data lookups have one source each — get_task_composer_config_path() finds the config the distribution installed through its file record, in a wheel and an editable install alike, and get_tesseract_resource_path() reads only the [support] distribution; neither falls back to $TESSERACT_CPP_PREFIX/share.
  • Docs fixes — the low-level snippet loads a robot from files with the id getters, allowed-collision-matrix examples use LinkIdPair keys and the one-pair isCollisionAllowed, the Robot.ik signature lists tip_link as required, plugin load timings are the measured ones with the hardware stated, and the 0.34 to 0.35 notes lose internal migration notes and unmeasured performance claims.
  • Binding lifetimes and locking — a CompositeInstruction call that would reallocate, shift or free elements (push_back, insert, del, clear, pop_back, setInstructions, reserve, shrink_to_fit) while Python holds a reference into them raises InstructionHeldError; Environment.getLink / getJoint return the shared link or joint, valid after a command removes it; clone() of contact managers and of forward and inverse kinematics keeps the original and its plugin library alive; environment events and ContactResultMap.filter callbacks get copies they may keep. Every Environment method waits for the environment's lock without the GIL, so an event callback and a writer on another thread no longer deadlock. Environment.applyCommand(command) is one overload for every command type.
  • Emitter correctness — every dialect emits each move's working frame, TCP frame and offset from its ManipulatorInfo; RAPID robtargets carry exact confdata (cf1/cf4/cf6 from the seed, cfx from the arm posture), typed declarations (CONST robtarget p1 := ...) and a DO on WHILE, and the DSL rejects misplaced PROC, PERS and declarations; JBI emits integer pulses and raises for a Cartesian move instead of writing the IK seed; KUKA ABC angles at B = +90 deg rebuild the input rotation; Fanuc CONFIG and UT / UTOOL_NUM follow the resolver and the bound tool; URScript FREESPACE Cartesian moves pass the seed as qnear; KRL approximation_mm sets $APO.CDIS and C_DIS. Moves with more than six joint values raise ExternalAxisError on KRL, LS, JBI and URScript, KRL FREESPACE Cartesian moves raise MissingConfigurationError, JBI and URScript emit analog outputs, and named signals raise outside RAPID. One display precision for all dialects: mm with 3 decimals, degrees 4, radians and metres 6, quaternions 9. Comments and TPWrite strings cannot break out of their syntax, emits are thread-safe and no longer clear a DSL program being built, the identity reports the installed version, Dwell rejects NaN, infinite and negative durations, and zigzag_square is tool down. Emitter validation errors are named (InvalidProfileError, InvalidLayoutError, InvalidDeclarationError, ProgramStructureError, ...).
  • Examples fail loud — planning examples raise PlanningFailedError instead of printing and returning a failed result; the chain, hybrid, puzzle-piece and online examples no longer swallow exceptions; online_planning_sqp_example raises when the initial solve does not converge or a replanning QP step fails; Environment.init and time-parameterization results are checked explicitly, not through assert. shapes_viewer uses the current resource locator, twc_workcell_positioner_viewer resolves twc_support in run() / main() (--twc-support, TWC_SUPPORT_PATH, submodule), online_planning_example is documented as a task-composer variant and not a port of the C++ example, and pick_and_place_example uses the C++ example's box (0.2 m at (0.15, 0.4)). tesseract_pythonic_api_example is a console script.
  • Python-surface validation — CartAxis constraints raise DegenerateAxisError for a zero or non-finite axis; trajopt_ifopt.python_constraints raises BoundsShapeError, InvertedBoundsError and ClearanceMarginError; a Descartes Python profile whose create* returns the wrong type raises ProfileReturnTypeError at creation. OSQPEigenSolver and TrajOptIfoptOSQPSolverProfile share one set of OSQP settings with getters; ContactResultVector takes negative indices; trajopt_ifopt is a package (imports unchanged); every public member of Environment, StateSolver, SRDFModel, SceneGraph and the time-parameterization profiles has a docstring.

0.35.0.8 - 2026-09-18 — TrajOptIfopt tuning + Cartesian planning fixes

  • Cartesian planning works with the default pipeline — plan_cartesian() and TaskComposer.plan_cartesian() now select the registered, double-precision DescartesDPipeline; the previous DescartesPipeline name did not exist in the generated configuration. Pipeline names and Descartes setup-cost guidance are corrected in the API and user guides (74c00ef9).
  • Planning failures identify the failing task — PlanningResult.message now reports the failed node and its specific diagnostic, such as a TrajOpt iteration limit or a failed contact check, instead of hiding it behind ErrorTask: Error (Abort Triggered) (74c00ef9).
  • Basic Cartesian examples match the C++ scene and tool orientation — both the high-level and low-level examples now build the reference obstacle from point-cloud data as an octree, replacing the smaller solid box, and use the reference TrajOpt profiles. The Eigen quaternion is correctly reordered to scalar-last [0, 1, 0, 0], restoring the intended downward tool orientation (74c00ef9).
  • macOS OpenMP troubleshooting — documented the duplicate libomp runtime problem when a bundled wheel is installed alongside conda NumPy, including diagnosis and installation guidance for multithreaded Descartes crashes; the packaging limitation remains unresolved (74c00ef9).
  • TrajOptIfopt collision configs and SQP parameters bound — TrajOptIfoptDefaultCompositeProfile exposed only smoothing and TrajOptIfoptSolverProfile only OSQP settings, so from Python the IFOPT planner ran on C++ collision and SQP-loop defaults with no way to reach them. collision_cost_config / collision_constraint_config (trajopt_common::TrajOptCollisionConfig) and opt_params (trajopt_sqp::SQPParameters) are now bound. opt_params sits on the base solver profile — create() assigns it straight onto the TrustRegionSQPSolver, making it the only route to max_iterations (50), max_qp_solver_failures (3), the trust-region ratios, and merit-coeff inflation; the sco back-end has always exposed these via TrajOptOSQPSolverProfile, so an IFOPT migration silently lost them. The collision configs carry max_num_cnt, which only trajopt_ifopt honours (the constraint size must be fixed): it caps the collision constraint at that many rows per timestep, one per worst link pair, so QP size stops tracking contact count (eb92e15).
  • tesseract_motion_planners_trajopt_ifopt re-exports the types its profiles need — TrajOptCollisionConfig, SQPParameters, and CollisionEvaluatorType are re-exported from the planner module, matching tesseract_motion_planners_trajopt, so configuring a composite or solver profile no longer means importing from trajopt_ifopt / trajopt_sqp / tesseract_collision alongside it. The module's __all__ also regains TrajOptIfoptMoveProfile, TrajOptIfoptDefaultMoveProfile, and ProfileDictionary_addTrajOptIfoptMoveProfile, which the stub declared but the package never re-exported.
  • CartPosConstraint's per-axis coefficients + bounds constructor bound — only the equality-form ctor was wired, so from Python the constraint was an equality on all six axes at unit weight, with no way to free an axis or give one an asymmetric bound. The second C++ ctor (coeffs, std::vector<Bounds>) is now an additive overload, so existing callers are unaffected; toBounds(lower, upper) was already exposed to build the band. See Low-Level SQP API → Per-axis Cartesian constraints in the user guide for what the coefficients and RangeBoundHandling do.
  • TrajOpt factory collision margins — create_trajopt_default_profiles() and create_freespace_pipeline_profiles() carried C++ car_seat_example.cpp's collision buffers and coefficients but not its margins, so default_margin stayed None and the collision cost held nothing off obstacles: over OMPL seeds 1-100 the freespace example passed a median 0.17 mm from its sphere and failed the pipeline's contact check on 3. The constraint now gets C++'s 0 m margin and the cost its 5 mm: closest pass 4.98 mm, no failures (#103, #135).
  • Low-level TrajOptIfopt example parameterizes time with ISP — TOTG failed 14 of 200 OMPL seeds on TrajOptIfopt's trajectories ("Negative path velocity"); ISP, which tesseract's own TrajOptIfoptTask runs, failed none (#103, #135).
  • OMPL example tests hold for every seed — the per-test seed reaches OMPL only on Linux and macOS (conda-forge's Windows ompl.lib is static), so it hid the two failures above rather than preventing them. The seeds that exposed them replay as tests, and a seed-free test holds the freespace path at least half the cost margin off its obstacle (#103, #135).
  • Margin vs buffer, docs and puzzle-piece ports — the migration guide mapped 0.2x's safety_margin onto collision_margin_buffer, which trajopt_common documents as "not used when calculating the error"; it maps onto contact_manager_config.default_margin. Corrected across the migration, planning, TrajOpt API and concepts pages, and the three puzzle-piece examples now set C++'s 25 mm cost margin (#135).

0.35.0.7 - 2026-07-24 — multi-brand emitter subsystem + coordinated external axes

  • Brand-independent multi-dialect emitter — the ABB-only RAPID emitter (shipped in 0.35.0.1) is generalised into a typed intermediate representation and lowering pass feeding per-dialect backends over a shared ProgramBackend ABC, so a new controller language is a backend, not a fork. Five dialects emit from one tesseract CompositeInstruction — ABB RAPID, KUKA KRL, Fanuc LS (TP ASCII), Yaskawa Motoman JBI (INFORM), and Universal Robots URScript — all exported from tesseract_robotics.emitters with a mermaid architecture page. RAPID is reseated onto the core IR and decomposed into profile / targets / emit / backend modules; its public surface (emit_rapid, RapidProfile, rapid_writer) is preserved through re-exports, so existing callers are unaffected (#128).
  • External-axis (eax) emission for coordinated motion — RAPID robtarget / jointtarget now carry real external-axis values (linear track in mm, rotary positioner in deg) instead of the 9E9 sentinel, split off the joint vector by joint name so a positioner ordered ahead of the arm can't bleed into the arm axes; external_axes=None stays byte-identical to prior output. Emitted programs also gain an ASCII-safe generated header and explicit UTF-8 writes so they survive Windows' locale codec (#127, #128).
  • createInvKin / createFwdKin teardown SIGSEGV fixed — the returned solver holds raw pointers into the scene graph, scene state, and plugin factory, so nb::keep_alive binds those to the solver's lifetime (the factory owns the dylib whose vtables the solver dispatches through). Coupled ROP/REP external-axis solvers no longer double-free at interpreter shutdown — the same destruction-order class fixed for plugin getters in 0.35.0.5 (gh-72), now closed for the kinematics factory functions (#126).

0.35.0.6 - 2026-07-04 — runtime kinematics commands + SQP GIL release

  • AddKinematicsInformationCommand + KinematicsPluginInfo bound — inverse/forward-kinematics solver plugins and named kinematic groups can be added to an environment at runtime from Python via an environment command, instead of only through the SRDF at load time (#125, e51946f).
  • GIL released in TrustRegionSQPSolver.solve (plus FK and setCollisionObjectsTransform) — mirrors the collision and motion-planner call_guard<gil_scoped_release> guards so long SQP optimisations run off the main thread without blocking other Python work (#123, 0f12535).

0.35.0.5 - 2026-06-20 — Descartes in the high-level API + collision GIL release + teardown & wheel fixes

  • contactTest releases the GIL — parallel collision checking across cores — DiscreteContactManager.contactTest and ContinuousContactManager.contactTest now bind with nb::call_guard<nb::gil_scoped_release>(), mirroring the motion planners' solve() guards. Without it a Python worker thread sweeping a trajectory for collisions only time-shared the GIL with the main thread (concurrency, not parallelism — the sweep didn't get faster and contended with the UI); with it, sweeping on per-thread cloned managers scales near-linearly — measured 1.95× on 2 threads (10-core machine) against a 0.99× pure-Python control that rules out a measurement artifact. Enables off-main-thread, sharded collision scans of a whole program (#122).
  • Plugin-backed objects keep their Environment alive — fixes the gh-72 SIGSEGV lottery — getKinematicGroup / getJointGroup / getDiscreteContactManager / getContinuousContactManager now bind with nb::keep_alive<0, 1>. These objects are plugin-created (OPW/KDL/UR kinematics, bullet/fcl collision factories) and their vtables live in dylibs owned by the Environment's plugin loader; when Python destroyed the Environment first (interpreter-teardown dict order, pytest GC), the loader dlclosed the plugin dylibs and the survivors' destructors virtual-called into unmapped pages. Whether a given script crashed was pure destruction-order luck — the reported "calcJacobian segfaults under pytest but works in plain Python" was this lottery, not the jacobian path (lldb forensics: dangling vptr pinned inside unloaded libtesseract_kinematics_opw.dylib) (#72).
  • Linux wheels: libstdc++ no longer bundled — fixes dual-copy heap corruption — the ldd-closure bundling swept the conda env's gcc-14 libstdc++.so.6 into every wheel; numpy/scipy load the system copy, the loader unifies STB_GNU_UNIQUE locale statics across the two, and std::regex inside PropertyTree::rebuildAutoValidators freed a stack address during Environment.init (SIGSEGV/double free or corruption — detection-dependent UB, so the pytest suite corrupted silently). The gcc runtime (libstdc++, libgcc_s) is now excluded from bundling, the GH #35 RTLD_GLOBAL preload is removed (its "two copies coexist safely" premise was falsified), and a test-wheel CI guard asserts ships-no-copy / one-copy-mapped / numpy-first env.init clean. Wheels now require a gcc-13+ era system or conda libstdc++ (ubuntu 24.04+, debian 13+); older distros fail loudly at import. Full forensics: docs/developer/linux-wheels.md (#119).
  • Basic Descartes example — descartes_raster_c_api_example.py, low-level port of upstream motion_planners/examples/raster_example.cpp: a 3-pass raster program solved by DescartesMotionPlannerD directly (no TaskComposer) with TrajOpt refinement chained on the result; CompositeInstruction gains the full C++ constructor (profile, manipulator_info, order) so UNORDERED transition composites are constructible from Python (#87).
  • Descartes woven into the high-level planning API — new create_descartes_pipeline_profiles() for the standalone DescartesF/D(NPC)Pipeline family, and create_descartes_default_profiles() grows the 0.35 knob surface: tool-axis rotation sampling for axis-symmetric processes (sample_axis/sample_resolution/sample_min/sample_max → target_pose_fixed=False), ik_solver override, use_redundant_joint_solutions, and move_profile= injection of custom (Python-subclassable, #83) DescartesMoveProfileD instances — mutually exclusive with the knobs, fails loud (#85).
  • Lowlevel planning example: TrajOpt profiles reach the solver — tesseract_planning_lowlevel_c_api_example.py added its TrajOpt plan/composite profiles to the OMPL dictionary while handing the solver an empty trajopt_profiles; TrajOpt silently planned on fallback defaults (#115).
  • get_task_composer_config_path() resolves like the runtime — returns the @PLUGIN_PATH@-patched config that _configure_environment() publishes via TESSERACT_TASK_COMPOSER_CONFIG_FILE (env var → bundled data → conda share) instead of unconditionally returning the bundled-only path, which doesn't exist in dev envs and was unpatched in wheels; raises the new TaskComposerConfigNotFoundError when nothing resolves; the hand-rolled fallback chains in the task composer tests, TaskComposer.from_config, and scripts/generate_pipeline_dotgraphs.py now delegate to it (#110).
  • ruff enforces the py39 floor — FA102 added to lint select so PEP 604 unions without from __future__ import annotations fail the hooks; with target-version = "py39" (rejects 3.10+ syntax) this turns 3.9 compatibility from convention into a gate (#92).
  • Symmetric shared_ptr<Environment> serialization writers — the environment write path now mirrors the reader, fixing the polymorphic cast that broke environment_from_* deserialisation round-trips (#121, bcac229).

0.35.0.4 - 2026-06-08 — conda-forge C++ deps + OSQP tunability + Linux libstdc++ preload + CI hardening

  • OSQP solver settings exposed — OSQPEigenSolver gains seven tunable setters (setPolish, setWarmStart, setAdaptiveRho, setMaxIteration, setAbsoluteTolerance, setRelativeTolerance, setVerbosity) and TrajOptIfoptOSQPSolverProfile gains setAdaptiveRhoInterval, enabling iteration-based (deterministic) rho adaptation for reproducible SQP solves; fixes dangling-pointer segfault in getJacobian() via rv_policy::reference_internal on getVar/getNode/getNodes (0f40048, c984044, c083f5e, #103).
  • OMPL RNG determinism — RNG_setSeed/RNG_getSeed bound in tesseract_motion_planners_ompl; conftest.py auto-reseeds per test for xdist-safe reproducibility; single-planner + optimize=False recipe documented as the only guaranteeable determinism contract (parallel-plan best-of-N races even with seeded samplers); Windows determinism test dropped — conda-forge ompl.lib embeds a separate RNGSeedGenerator copy per DLL so seeding the extension can't reach the planner (a0f49c6, 5f4776e, 31c7541, #103).
  • conda-forge C++ deps — C++ stack migrated from colcon workspace build to conda-forge prebuilts; pixi install && pixi run build replaces pixi run build-cpp / colcon; pixi.lock v7 with eigen-abi-tagged orocos-kdl _2 ending heap corruption in all KDL paths; locked:true + pinned pixi-version in CI so stale-lock drift fails loud; build-dir cache keyed on pixi.lock hash; Python 3.9 feature env added for Rhino 8 (b6a14c4, 3c80a25, 6210a99, 0455e34).
  • Linux libstdc++ preload — bundled gcc-14 libstdc++ loaded RTLD_GLOBAL as the first act of __init__ wins the SONAME race before numpy/scipy can pull in the system copy on Ubuntu 22.04 and older; gated on CONDA_PREFIX absence to avoid double-loading inside pixi/conda envs (#35, ee83dc8, 7715422).
  • Environment.setState input validation — unknown or non-active (fixed/mimic) joint names now raise ValueError with a clear message instead of silently dereferencing unmapped entries and crashing with SIGSEGV; all three entry points covered (dict, names+values, setStateByNamesAndValues) (#43, ca620d3).
  • SceneGraph type registration in URDF module — _tesseract_urdf now imports _tesseract_scene_graph at module load so the return type of parseURDFFile is always registered; was masked by full-suite imports, exposed by the new minimal-import ABI canary (f944293).
  • CI hardening — Windows test-wheel now runs the full suite (kinematics + examples, benchmarks-only exclusion); macOS nanobind build directory cached to halve warm builds; ABI canary (install wheel into pixi env → kinematics smoke-test) on Linux and macOS build jobs catches dep-ABI rot in ~30 s instead of as scattered segfaults in test-wheel; duplicate CI env block merged (e60f272, b29c37a, 04a812f, 6210a99, 607b4b9).
  • Dotgraph polish — TaskComposer pipeline diagrams woven into docs; clean_dot_labels strips dump-debug fields for legibility; contract test + type annotations (4aa5efb, 57537da, 1bfb4c3).

0.35.0.3 - 2026-06-05 — complete wheel matrix for the 0.35.0.2 content

Reissue of 0.35.0.2 with the full wheel set actually published. In 0.35.0.2 a dirty CI build tree made setuptools_scm stamp a PEP 440 local segment (+d<date>) onto some wheels; PyPI rejects those with HTTP 400, and the non-idempotent publish step aborted mid-upload — so macOS (all) and Linux x86_64 (cp39/cp311) wheels never landed. 0.35.0.2 is yanked. Identical bindings to 0.35.0.2 — no API changes (49f1aa9).

  • Release pipeline hardened — setuptools_scm local_scheme = "no-local-version" so a dirty tag build can't produce a PyPI-rejected local version; skip-existing: true on all three publish workflows so re-runs fill gaps instead of 400-aborting; macOS fail-fast: false so one flaky build can't cancel sibling wheels; plus a 3× retry on the macOS upload-artifact step working around GitHub's long-standing arm64-runner CreateArtifact timeout (actions/upload-artifact#569, still open) that otherwise skips the entire macOS publish ~80% of the time (49f1aa9, 804d5b8).
  • cp312-abi3 support verified on all platforms — macOS and Windows test-wheel now install the cp312-abi3 wheel on Python 3.13/3.14 (mirroring Linux; wheel != python), so the published 3.9–3.14 support matrix is verified in CI, not just asserted (14a4cea).

0.35.0.2 - 2026-06-04 — aarch64 / Jetson Linux wheels + collision manager bindings

Extends Linux wheel coverage to aarch64 (including NVIDIA Jetson), completes the contact-manager binding surface, and hardens the new ROS RPY decomposition against gimbal-lock edge cases (#97, 669f2da, f30014b).

  • aarch64 / NVIDIA Jetson Linux wheels — new GitHub Actions matrix entry plus Jetson build patches, built for Python 3.12+ on aarch64; Linux wheel CI standardised on pixi run build-cpp / build-wheel (#52, dc3f1df, 605dc4d, af7bc4e, #91, ba0510f, c897251, @Joelkang).
  • Collision manager bindings completed — remaining discrete/continuous contact-manager surface plus Descartes MoveProfile contact-manager config (#94, 9bfd6b1, 7a3b0e3, @Joelkang).

0.35.0.1 - 2026-05-29 — tesseract 0.35.0 upgrade + Eigen geometry suite + RAPID emitter

Major dependency bump to tesseract 0.35.0, a complete Eigen geometry binding surface with scalar-last quaternions as the project canon, a Pose that now is an Isometry3d, and a new ABB RAPID code emitter. (First wheel release of the 0.35 series; the project's setuptools_scm scheme requires four-component tags, so it is 0.35.0.1, not 0.35.0.)

  • Complete Eigen geometry binding suite — fleshed-out Vector3d / Vector4d / Matrix3d / Quaterniond / AngleAxisd / Isometry3d surface, with scalar-last [qx, qy, qz, qw] Quaterniond.from_xyzw and Quaterniond.from_rpy / to_rpy ZYX ROS RPY interop; float64 default precision centralised via Eigen NumTraits (#76, 492ab7a, 544f7dd, 1d6f5c7, ef26fc9).
  • ABB RAPID code emitter for tesseract_command_language (tesseract_robotics.emitters.rapid) (#75, 37f21b2).
  • Octree geometry bindings (plus octomap::OcTree, OctreeSubType, PointCloud, createOctree) and the remaining tesseract_geometry utilities (isIdentical, extractVertices, toTriangleMesh) (#67, 4575aa9, @Joelkang).
  • Python-subclassable Descartes evaluators/sampler/profile for tesseract_motion_planners_descartes — new bindings for DescartesStateD, DescartesStateSampleD, DescartesEdgeEvaluatorD, DescartesWaypointSamplerD, DescartesStateEvaluatorD, and a now-subclassable DescartesMoveProfileD let users override createWaypointSampler / createEdgeEvaluator / createStateEvaluator from Python (#83, 620b228, @Joelkang).
  • Upgraded to tesseract 0.35.0 — deps bumped (rosinstall → repos), MIGRATION.md sed applied, namespace aliases added, resource URIs and dev paths updated for the 0.35 layout, wheel data dir tesseract_support → tesseract/support, kinematics_core_factories → kinematics_factories, descartes tp::MoveInstructionPoly → tcl::MoveInstructionPoly (#86, 6710ccf, 422c5ea, 4e08a36).
  • Pose now subclasses Isometry3d (tesseract_robotics.planning) — rotation math via Eigen, numpy-property facade dropped, factories collapsed to one name accepting both scalar-positional and arraylike call styles, Transform alias removed in favour of the single canonical Pose, stored-data accessors exposed as properties (#76, a202a45, caa3b19).
  • Scalar-last quaternions declared project canon — [qx, qy, qz, qw]; Quaterniond(w, x, y, z) literals migrated to Quaterniond.from_xyzw (0bd408d, f7b2fea).
  • README gains an examples section and a refreshed platform-support matrix (d7bde99, 8eed899).
  • KinematicsInformation.group_tcps exposed to Python (tesseract_srdf) (#79, 52fdfba).
  • TaskComposerNodeInfoContainer returns TaskComposerNodeInfo (#81, 106d162, @Joelkang).
  • getSeed() exposed on CartesianWaypoint (#80, 0c57074, @Joelkang).
  • Viewer light color (#73, 3b4c545, @johnwason).

0.34.1.7 - 2026-05-09 — command_language I/O instructions + TaskComposer introspection

Python API surface expansion: tesseract_command_language gains its remaining I/O and pacing instruction types (Wait, Timer, SetAnalog, SetDigital, SetTool) — closing the gap that previously forced raster and pick-and-place pipelines through C++ or YAML — alongside TaskComposer DAG visualisation via GraphViz DOT output and TaskComposerDataStorage introspection helpers. Welcomes @seonixx (Simon White) as a new contributor.

  • Remaining tesseract_command_language instruction types bound: WaitInstruction, TimerInstruction, SetAnalogInstruction, SetDigitalInstruction, SetToolInstruction, with their WaitInstructionType / TimerInstructionType enums and InstructionPoly_as_* cast helpers. Closes the I/O-and-pacing gap that previously forced raster/pick-and-place pipelines to be authored in C++ or YAML. New tests/tesseract_command_language/test_command_language.py covers construction, casting, and InstructionPoly round-tripping (#70, a4c26df, @Joelkang).
  • TaskComposer DAG visualisation — getDotgraph() / saveDotgraph() overloads on TaskComposerNode, with an optional TaskComposerNodeInfoContainer argument to highlight the executed path on a previously-run DAG. Emits GraphViz DOT for debugging otherwise-opaque planning pipelines (#63, e7c3a92, @Joelkang).
  • TaskComposerDataStorage AnyPoly cast/wrap helpers — AnyPoly_wrap_TaskComposerDataStorage and AnyPoly_as_TaskComposerDataStorage, so DAG storage state can be inspected after each node from Python instead of only via C++ (#66, b30ed46, @Joelkang).
  • TaskComposerDataStorage.getAllData() no-arg overload binding returning the full data map (#66, 990705f, @seonixx).
  • DiscreteContactCheckTask exposes contact_results through task_infos data_storage, with unit and integration test coverage (#66, 4fe07bf, 06178f0, @seonixx).
  • SimplePlanner and time-parameterization profiles now reachable via the public tesseract_motion_planners_simple and tesseract_time_parameterization package paths instead of only the underscore-prefixed C++ extension modules. C++ binding-side registrations retired in favour of __init__.py re-exports; test_constant_tcp.py consolidated into test_time_parameterization.py (#62, d73e227, 30c8e9f, @Joelkang).
  • InstructionPoly_as_CompositeInstruction re-exported from tesseract_command_language package init — was bound but not surfaced (#70, 110e1e0, @Joelkang).

0.34.1.6 - 2026-04-27 — PyPI README refresh

Same wheels as 0.34.1.5; recut so the published wheel's README metadata includes the Windows build badge alongside Linux and macOS on PyPI's project page.

  • README badge row includes a Windows build badge (6656815).

0.34.1.5 - 2026-04-27 — Windows x64 wheels debut + Python profile bindings

First complete cross-platform PyPI release: Linux, macOS, and Windows wheels for Python 3.9–3.12. Closes the long-running #40 Windows wheels initiative (#58). Also ships a batch of profile-binding contributions from @Joelkang that had been queued in Unreleased.

  • Windows x64 wheels published to PyPI via the new wheels-windows.yml workflow. Mirrors wheels-{linux,macos}.yml; sources C++ deps from conda-forge via pixi; bundles plugin DLLs via delvewheel repair --analyze-existing (f9c122d, 3e3a2e4).
  • __init__.py prepends the package dir and tesseract_robotics_nanobind.libs/ to PATH on Windows — required because boost::dll's plain LoadLibrary ignores os.add_dll_directory (006ce38).
  • Cereal polymorphic types re-registered in the tesseract_serialization binding TU — MSVC instantiates the cereal registry per-DLL, so upstream's registrations don't reach the consumer .pyd without re-registration (af88515).
  • New developer doc docs/developer/windows-wheels.md capturing four Windows wheel packaging gotchas surfaced during the gh-40 diagnosis (fe5ad75).
  • CompositeInstruction.push_back now accepts a CompositeInstruction in addition to a plain Instruction, enabling nested composites (e.g. raster programs) to be built from Python the same way they are in C++ (#51, 6d17314, @Joelkang).
  • SimplePlanner profiles configurable from Python — SimplePlannerCompositeProfile plus seven concrete move profiles (FixedSize, FixedSizeAssign, FixedSizeAssignNoIK, LVS, LVSNoIK, LVSAssign, LVSAssignNoIK), with ProfileDictionary_addSimplePlannerMoveProfile / …CompositeProfile helpers for registration (#54, e2bf837, @Joelkang).
  • task_composer planning-node profiles exposed through a new tesseract_task_composer_planning module: ContactCheckProfile, FixStateBoundsProfile, FixStateCollisionProfile, KinematicLimitsCheckProfile, MinLengthProfile, ProfileSwitchProfile, and UpsampleTrajectoryProfile. Heavy TrajOpt-typed members on FixStateCollisionProfile (OSQP settings, SQP params, coeff data) are intentionally skipped — configure those via YAML or C++ (#56, 62cd2cd, @Joelkang).
  • ConstantTCPSpeedParameterization (KDL-based, constant TCP-speed time parameterization) bound alongside its ConstantTCPSpeedCompositeProfile (#55, f4f981d, @Joelkang).
  • vcpkg-based wheels-windows.yml variant (workflow_dispatch-only, never green) replaced by the conda-forge / pixi pipeline of the same name (3e3a2e4).

0.34.1.4 - 2026-04-27 [YANKED] — partial cross-platform release

Yanked. Linux and macOS wheels published successfully; Windows wheels built and tested but the publish job hit a PyPI Trusted Publisher configuration mismatch and didn't upload. Superseded by 0.34.1.5.

0.34.1.2 - 2026-04-23 — macOS arm64 stability

Follow-up to the macOS arm64 debut in 0.34.1.1, resolving a garbage-collection crash that surfaced in fresh virtual environments during motion planning.

  • Dedupe versioned dylibs in the wheel — the actual root cause of the macOS GC crash (#48, 7f53185).
  • Pin plugin dylibs on macOS to prevent a garbage-collection crash during motion planning (#48, 590343f).
  • Restore the CI macOS test scope that had been narrowed as a workaround for #48 (#49, 07f8f9c).

0.34.1.1 - 2026-04-23 — macOS arm64 wheels debut

First PyPI-published macOS arm64 wheels, shipping via a dedicated wheels-macos.yml workflow parallel to the existing Linux x86_64 pipeline. Also introduces a Python trampoline for ConstraintSet, Python 3.9 compatibility for example modules, and installable example scripts.

  • macOS arm64 wheels published to PyPI via a split, per-platform workflow (d80e689).
  • Python trampoline for ifopt.ConstraintSet so users can subclass it from Python for custom SQP constraints (361c60e).
  • Examples installable as console scripts (e.g. tesseract_basic_cartesian_example) via [project.scripts] (2c62952, @marip8).
  • pixi run build-wheel task for local wheel builds (e26df2a).
  • Non-benchmark tests fail loud instead of being silently skipped (a1d7607).
  • Python 3.9 compatibility for example modules via from __future__ import annotations (87ce68e).