v0.5.2

This release improves model reuse, batch computation, and numerical robustness.

• Model reuse: Add read-only RobotModel metadata and Python fork() to share model data while keeping calculation state independent.
• Batch computation: Add all-link forward kinematics across Rust, C, C++, and Python, reusable LoadBuffer storage, and C++ preallocated output APIs.
• Numerical robustness: Improve floating-base inertia solves for small inertias and varying mass scales.
• Input validation: Strengthen checks for joint parameters, external loads, and tools, with better overflow detection and error recovery.
• Quality and maintenance: Forbid unsafe code in the core library, expand cross-language, zero-allocation, and Pinocchio comparison tests, and refresh documentation and benchmarks.

v0.5.1

v0.5.1

• Removed the legacy Python ctypes fallback; Python now requires the PyO3 native extension.
• Public Python exports remain unchanged.
• No changes to the Rust core or C/C++ bindings.

v0.5.0

dynibo v0.5.0

v0.5.0 upgrades the Python bindings and improves core kinematics and dynamics performance.

• Migrated Python bindings to a native PyO3/Maturin extension, with support for Python 3.9–3.14.
• Added NumPy float64 array support. Contiguous inputs use a zero-copy path, and major compute methods now accept out= buffers for reuse.
• Python vector and matrix results now return NumPy arrays; numpy>=1.23 is now a runtime dependency.
• Optimized Jacobian, RNEA, and ABA paths, with new Franka and floating-base Unitree G1 benchmarks.
• Added and refined Franka and Unitree G1 examples for Rust, Python, and C++, including bundled model license information.
• Expanded Python, external-load, and installed-package test coverage; refreshed English and Chinese documentation.

Upgrade notes

Python users relying on tuple or list return values should update their code to handle NumPy arrays. For performance-sensitive control loops, preallocate output arrays and pass them through out=.

v0.4.1

v0.4.1

Maintenance release focused on testing and packaging:

• Improved allocation-test reliability.
• Unified version management across Rust, C/C++, and Python packages.
• Improved package validation and release automation.

No API changes.

Full Changelog: v0.4.0...v0.4.1

v0.4.0

Dynibo v0.4.0

Dynibo v0.4.0 adds forward dynamics, introduces separate fixed-base and floating-base APIs, and expands testing and package distribution.

Highlights

• Added linear-time articulated-body forward dynamics for Rust, Python, C++, and C.
• Introduced dedicated Robot and FloatingRobot types.
• Floating-base calculations now receive BaseState explicitly.
• Rust robots now own their reusable workspaces; use fork() for independent parallel calculations.
• Expanded generated-URDF, Pinocchio, allocation, and cross-platform package tests.
• Added prebuilt C/C++ packages for Linux, macOS, and Windows with SHA256SUMS.

Breaking changes

• Removed BaseMode and from_urdf_with_base.
• Use FloatingRobot::from_urdf for floating-base models.
• Rust calculation methods no longer accept a separate Workspace.
• Floating-base state is no longer stored on the robot.
• C, C++, and Python now use distinct fixed/floating robot APIs.

See the migration documentation for updated examples.

Installation

Rust:

cargo add dynibo@0.4.0

Python:

python -m pip install dynibo==0.4.0

C/C++ users can download a matching prebuilt package from this release or build from source with Cargo and CMake.

Full Changelog: v0.3.0...v0.4.0

v0.3.0

Dynibo v0.3.0

Dynibo v0.3.0 adds floating-base robot support, refines the dynamics APIs, and brings the Rust, C, C++, and Python interfaces into a more consistent shape.

Highlights

• Added fixed- and floating-base robot modes.
• Added floating-base kinematics and dynamics across Rust, C, C++, and Python.
• Added generalized Jacobians, mass matrices, gravity forces, velocity-product forces, and inverse dynamics for floating-base systems.
• Added explicit base pose, velocity, and acceleration handling.
• Added bilingual English and Chinese documentation with unified API guides and examples.
• Expanded allocation, numerical-property, language-binding, and Pinocchio reference tests.
• Refactored model initialization and split kinematics and dynamics algorithms into focused modules.

Breaking changes

• Fixed joints are no longer included in runtime joint-state vectors. Configuration, velocity, acceleration, and generalized-force arrays now contain moving joints only.
• Coriolis matrix APIs have been replaced by velocity-product force APIs, which directly compute Coriolis and centrifugal generalized forces.
• Rust calculation methods now receive a BaseState explicitly.
• Several C, C++, and Python APIs and examples have been renamed or reshaped to align with the Rust API.
• Applications compiled against the v0.2 C ABI should be rebuilt against the v0.3 headers and library.

Documentation

The documentation now includes:

• Fixed- and floating-base conventions
• Joint and generalized-coordinate ordering
• Frames and spatial-vector conventions
• Kinematics and dynamics guides
• External-load handling
• Workspace reuse and allocation behavior
• Rust, C, C++, and Python API mappings
• English and Chinese versions of the main guides

Packaging

This release publishes:

• The dynibo Rust crate to crates.io
• Python wheels for Linux, macOS, and Windows
• A Python source distribution on PyPI
• C and C++ headers and native-library packaging through CMake/CPack

Full Changelog: v0.2.0...v0.3.0

v0.2.0

v0.2.0

Added

• Added joint-space mass matrix computation via Robot::mass_matrix.
• Added Coriolis and centrifugal matrix computation via Robot::coriolis_matrix.
  The implementation satisfies C(q, q̇)q̇ + g(q) = inverse_dynamics(q, q̇, 0).
• Added geometric Jacobian time-derivative computation via
  Robot::jacobian_derivative.
• Exposed the new mass-matrix, Coriolis-matrix, and Jacobian-derivative APIs
  through the C ABI, C++ wrapper, and Python bindings.
• Added API formulas to the Rust and Python documentation, plus hosted
  documentation support.

Changed

• Hardened C ABI validation: state input buffers may not overlap output buffers
  for the new matrix and Jacobian-derivative APIs.
• URDF loading now rejects non-finite inertial values, negative mass, and
  inertia tensors that are not positive semi-definite.

Validation

• Added numerical property tests, finite-difference checks, and Pinocchio
  reference coverage for the new dynamics APIs.
• Expanded C, C++, and Python package integration tests.

v0.1.0

Dynibo v0.1.0

The first public release of Dynibo, a fast, lightweight and reliable robot kinematics and dynamics library.