ROS Index
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Description | C++ Implementation of a Multibody Vehicle Dynamics Simulation |
| Checkout URI | https://github.com/tumftm/open-car-dynamics.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-02-24 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
README
Open Car Dynamics provides a comprehensive, modular, and highly efficient implementation of a vehicle's dynamic behavior. Following the philosophy of modeling vehicle behavior "in as much detail as necessary, but as simply as possible," the library drastically simplifies parametrization and adaptation to custom requirements. Written in modern C++ for maximum performance, the library offers seamless integrations for Python and ROS 2. Furthermore, vehicle dynamics has been rigorously validated against data recorded with the AV21 autonomous racecar used in the Indy Autonomous Challenge to ensure simulation accuracy and reliability.
[](https://www.python.org/) [](https://docs.ros.org/en/humble/) 
Table of Contents
- 1. How it works
- 2. Compiling and Running the Model
- 3. Parameters
- 4. Contributing
- 5. Related Projects
- 6. References
1. How it works
The model is designed to be an ordinary differential equation in state-space formulation. This state space model is solved using the Dormand-Prince scheme with a constant integration step size to enable real-time execution.
To achieve modularity, each vehicle model consists of 3 different submodels:
- Vehicle Dynamics
- Drivetrain
- Steering Actuator
The interfaces connecting the different models are shown in the following figure:
Furthermore, the vehicle dynamics models can incorporate submodels for modeling aerodynamics and tire behavior. However, these models are stateless, which distinguishes them from the 3 submodels mentioned above.
All of these 5 submodel components can be freely combined with each other, enabling a vast number of different vehicle implementations. With this design, our library is able to model a lot of different vehicles without modifying the source code, also enabling rapid extension and collaboration. New variations of any submodel can be created by just inheriting and implementing the corresponding base class.
The submodels are automatically combined at compile time (hence the heavy templating in this library) by concatenating their state vectors to form one big model. Since combination happens at compile time, the compiler is able to heavily optimize the model, making it highly efficient. Even the most complex model currently inside the repository achieves a full simulation time step (using Dormand-Prince~ode4 integration) with an execution time below 10 µs on our benchmark system (AMD Ryzen 9 7950X).
2. Compiling and Running the Model
The model and its different bindings (ROS 2, Python) can be compiled in multiple ways from source. First, ensure you meet the prerequisites in section 2.1.
Afterwards, refer to the respective subsection depending on how and what you want to compile.
2.1. Prerequisites
Before building, ensure you have the following installed:
- OS: Ubuntu 22.04 or 24.04
- Compiler: A modern C++ compiler (GCC/Clang) supporting C++20
- Build Tools: CMake (>= 3.18), Make/Ninja
- Libraries: Eigen3, Boost
- (Optional) ROS 2: Humble or Jazzy (for ROS 2 nodes and Python bindings)
- (Optional) Docker: If building Python bindings without a local ROS 2 installation
2.2. Clone Repository
First clone the repository using the command:
git clone --recursive https://github.com/TUMFTM/Open-Car-Dynamics.git
File truncated at 100 lines see the full file