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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |
Dependant Packages
Launch files
Messages
Services
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
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_ikpackage and unpack into your colcon workspace. - Run
colcon build --mixin releaseto 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_groupnode to move your robot. - As usual, the public API is specified in the public header files for the
bio_ikpackage, located in theinclude/bio_iksubdirectory; the sources including a few private header files are in thesrcsubdirectory.
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.yamlconfiguration 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
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake_ros | |
| ament_cmake_gtest | |
| moveit_core | |
| pluginlib | |
| moveit_ros_planning | |
| rclcpp | |
| tf2 | |
| tf2_eigen | |
| tf2_kdl | |
| tf2_geometry_msgs |
System Dependencies
| Name |
|---|
| eigen |