No version for distro humble showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro jazzy showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro kilted showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro rolling showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro galactic showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro iron showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro melodic showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange

No version for distro noetic showing github. Known supported distros are highlighted in the buttons above.

Package Summary

Version 2.0.0
License BSD
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/bit-bots/bitbots_main.git
VCS Type git
VCS Version main
Last Updated 2026-03-14
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

BioIK for ROS 2

Maintainers

  • Philipp Sebastian Ruppel
  • Michael Goerner

Authors

  • Philipp Sebastian Ruppel

bio_ik

Disclaimer

This repository provides a BSD-licensed standalone implementation of a variety of optimization methods to efficiently solve generalized inverse kinematics problems.

The whole module was implemented by Philipp Ruppel as part of his Master Thesis.

For a C++-based reimplementation of the original “BioIK” algorithm, as originally sold in the Unity store, you can use the non-default mode bio1. The default mode bio2_memetic shares no code with this implementation, was shown to outperform it in terms of success rate, precision and efficiency, and is actually usable for precise robotic applications [4].

Installation and Setup

You will need ROS 2 version Rolling or newer: https://docs.ros.org/en/rolling/Installation.html. This version of the software was developed on Ubuntu Linux 22.04 LTS with ROS 2 Rolling. Newer versions of ROS 2 should work, but may need some adaptation. See below for version specific instructions.

  • Download the bio_ik package and unpack into your colcon workspace.
  • Run colcon build --mixin release to compile your workspace:
    cd <PATH TO WORKSPACE>/src
    git clone -b ros2 https://github.com/TAMS-Group/bio_ik.git
    cd ..
    colcon build --mixin release
  
  • Configure Moveit to use bio_ik as the kinematics solver (see next section).
  • Use Moveit to plan and execute motions or use your own code together with move_group node to move your robot.
  • As usual, the public API is specified in the public header files for the bio_ik package, located in the include/bio_ik subdirectory; the sources including a few private header files are in the src subdirectory.

Basic Usage

For ease of use and compatibility with existing code, the bio_ik algorithm is encapsulated as a Moveit kinematics plugin. Therefore, bio_ik can be used as a direct replacement of the default Orocos/KDL-based IK solver. Given the name of an end-effector and a 6-DOF target pose, bio_ik will search a valid robot joint configuration that reaches the given target.

In our tests (see below), both in terms of success rate and solution time, bio_ik regularly outperformed the Orocos [1] solver and is competitive with trac-ik [2]. The bio_ik algorithm can also be used for high-DOF system like robot snakes, and it will automatically converge to the best approximate solutions for low-DOF arms where some target poses are not reachable exactly.

While you can write the Moveit configuration files by hand, the easiest way is to run the Moveit setup assistant for your robot, and then to select bio_ik as the IK solver when configuring the end effectors. Once configured, the solver can be called using the standard Moveit API or used interactively from rviz using the MotionPlanning GUI plugin.

  • Make sure that you have a URDF (or xacro) model for your robot.
  • Run the moveit setup assistant to create the Moveit configuration files:
  ros2 run moveit_setup_assistant moveit_setup_assistant

  
  • The setup assistant automatically searches for all available IK solver plugins in your workspace. Therefore, you can just select select bio_ik as the IK solver from the drop-down list for every end effector and then configure the kinematics parameters, namely the default position accuracy (meters) and the timeout (in seconds). For typical 6-DOF or 7-DOF arms, an accuracy of 0.001 m (or smaller) and a timeout of 1 msec should be ok. More complex robots might need a longer timeout.
  • Generate the moveit configuration files from the setup assistant. Of course, you can also edit the config/kinematics.yaml configuration file with your favorite text editor. For example, a configuration for the PR2 robot might look like this:

``` # example kinematics.yaml for the PR2 robot right_arm: # kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin # kinematics_solver_attempts: 1.0 kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 left_arm: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.005 kinematics_solver_attempts: 1.0 all: kinematics_solver: bio_ik/BioIKKinematicsPlugin kinematics_solver_search_resolution: 0.005 kinematics_solver_timeout: 0.02 kinematics_solver_attempts: 1.0

File truncated at 100 lines see the full file

CHANGELOG
No CHANGELOG found.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

Recent questions tagged bio_ik at Robotics Stack Exchange