cartan-bindings 0.4.2

Python bindings for cartan — C++20 Lie group, kinematics, and IK library

A C++20 rigid-motion and serial kinematics library.

Status

Public preview. The C++ API and Python bindings are under development; expect breaking changes onwards to a stable v1.0.0 release. The library builds and tests on Linux, macOS, and Windows and can be installed using FetchContent (see below). Python bindings will be available as pip install cartan-bindings (WIP).

Features

• Lie groups: SO(2), SE(2), SO(3), SE(3) with exp/log, adjoint, coadjoint, left/right Jacobians
• Product of Exponentials kinematics: screw-theory-based FK with compile-time unrolled PoE for 1-7 DOF chains
• Space and body Jacobians: reusing cached FK intermediate products for zero redundant computation
• Compile-time frame safety: transform<From, To> and rotation<From, To> wrappers with structural type checking
• Policy-based IK solvers: DLS, Levenberg-Marquardt, and SQP steppers composable with racing and fallback schedulers
• Header-only: no compiled library artifacts, Eigen as the sole required dependency

Scope

Cartan is a Lie-group, forward-kinematics, and inverse-kinematics library — and deliberately only that. It stays a small, composable library rather than a robotics framework, so the following are non-goals, each better served by a purpose-built tool cartan composes with:

• Dynamics (RNEA, mass matrix, gravity/Coriolis); use Pinocchio.
• Collision detection — use hpp-fcl / Coal.
• Motion / trajectory planning — use a planner (OMPL) or a time-parameterizer (TOPP-RA).
• State estimation / filtering — see ctrlpp.
• Visualization — use threepp or your own renderer.
• Middleware bindings (ROS / KDL / orocos) — zero coupling by design.
• Custom linear algebra — Eigen only; cartan reinvents no matrix math.

Cartan composes with these rather than absorbing them: its SE3 / SO3 types and FK / Jacobian outputs feed directly into a dynamics solver, a collision checker, or a planner. The guiding principle is library, not framework — cartan owns kinematics and stays out of everything else.

Requirements

• C++20 compiler: GCC 10+, Clang 13+, MSVC 17.x+
• CMake 3.28+
• Eigen 3.4+ (auto-fetched via FetchContent)
• For embedded targets: an exceptions-off C++20 GCC backend — ESP-IDF 5.1+ / 6.x (esp32, esp32c3) or arm-none-eabi (cortex-m7, cortex-m4f).

Quick Install

CMake FetchContent (recommended)

include(FetchContent)
FetchContent_Declare(
    cartan
    GIT_REPOSITORY https://github.com/skrede/cartan.git
    GIT_TAG        master
)
FetchContent_MakeAvailable(cartan)

target_link_libraries(my_app PRIVATE cartan::cartan)

This pulls Cartan and its Eigen dependency automatically. No manual installation required.

find_package

find_package(cartan CONFIG REQUIRED)
target_link_libraries(my_app PRIVATE cartan::cartan)

ESP-IDF Component Manager

Cartan ships an idf_component.yml at the repo root. Add it to your firmware project's main/idf_component.yml once it is published to the ESP Component Registry, or pin a Git revision directly:

dependencies:
  skrede/cartan:
    git: https://github.com/skrede/cartan.git
    version: "master"

Continuous integration cross-compiles a representative translation unit — forward kinematics, the body Jacobian, an allocation-free projected Levenberg-Marquardt IK step, and a Paden-Kahan subproblem — with C++ exceptions disabled (-fno-exceptions) for four target families: esp32 (xtensa) and esp32c3 (riscv32) via ESP-IDF, and Cortex-M7 and Cortex-M4F via arm-none-eabi. This proves the public headers compile for those targets exceptions-off; it does not run them on hardware. The compile-only sources live under tests/embedded/esp32-smoke/ (see that directory's README for the idf.py build recipe) and tests/embedded/arm-crosscompile/.

Documentation

• Getting Started — zero to compiling in 5 minutes.
• Documentation Index — API reference, background theory, guides.
• Examples — runnable programs for every feature area.
• Tutorials — step-by-step walkthroughs for FK, Jacobians, IK, and URDF loading.
• Python — tutorials and setup guide for Cartan's Python API.

Contributing

See CONTRIBUTING.md for the contribution workflow, coding conventions, and commit message format.

License

Apache License 2.0 — see LICENSE for the full text.

Copyright 2026 Aleksander Skrede.

Declaration of AI use

This library has been — and will be — developed with extensive use of Claude code (Sonnet, Opus and Fable).