Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time


A GPU-accelerated library for computing rigid body dynamics with analytical gradients.

GRiD wraps our URDFParser, GRiDCodeGenerator, and RBDReference packages. Using its scripts, users can easily generate and test optimized rigid body dynamics CUDA C++ code for their URDF files.

For additional information and links to our paper on this work, check out our project website.

This package contains submodules make sure to run git submodule update --init --recursive after cloning!

The GRiD library package ecosystem, showing how a user's URDF file can be transformed into optimized CUDA C++ code which can then be validated against reference outputs and benchmarked for performance.


  • To generate the grid.cuh header file please run: PATH_TO_URDF (-D) where -D indicates full debug mode which will include print statements after ever step of ever algorithm
  • To test the python refactored algorithms against our reference implmentations please run PATH_TO_URDF (-D) where -D prints extra debug values as compared to just the comparisons
  • To print and compare GRiD to reference values please do the following steps:
    1. Print the reference values by running PATH_TO_URDF (-D) where -D prints the full debug reference values from the refactorings
    2. Run PATH_TO_URDF (-D) to compile, run, and print the same values from CUDA C++

Current Support

GRiD currently fully supports any robot model consisting of revolute, prismatic, and fixed joints that does not have closed kinematic loops.

GRiD currently implements the following rigid body dynamics algorithms:

  • Inverse Dynamics via the Recursive Newton Euler Algorithm (RNEA) from Featherstone
  • The Direct Inverse of Mass Matrix from Carpentier
  • Forward Dynamics by combining the above algorithms as qdd = -M^{-1}(u-RNEA(q,qd,0))
  • Analytical Gradients of Inverse Dynamics from Carpentier
  • Analytical Gradient of Forward Dynamics from Carpentier

Additional algorithms and features are in development. If you have a particular algorithm or feature in mind please let us know by posting a GitHub issue. We'd also love your collaboration in implementing the Python reference implementation of any algorithm you'd like implemented!


To enable GRiD to be used by both expert and novice GPU programmers we provide the following API interface for each rigid body dynamics algorithm:

  • ALGORITHM_inner: a device function that computes the core computation. These functions assume that inputs are already loaded into GPU shared memory, require a pointer to additional scratch shared memory, and store the result back in shared memory.
  • ALGORITHM_device: a device function that handles the shared memory allocation for the \_inner function. These functions assume that inputs are already loaded into, and return results to, GPU shared memory.
  • ALGORITHM_kernel: a kernel that handles the shared memory allocation for the \_inner function. These functions assume that inputs are loaded into, and return results to, the global GPU memory.
  • ALGORITHM: a host function that wraps the _kernel and handles the transfer of inputs to the GPU and the results back to the CPU.

Citing GRiD

To cite GRiD in your research, please use the following bibtex for our paper "GRiD: GPU-Accelerated Rigid Body Dynamics with Analytical Gradients":

  title={GRiD: GPU-Accelerated Rigid Body Dynamics with Analytical Gradients}, 
  author={Brian Plancher and Sabrina M. Neuman and Radhika Ghosal and Scott Kuindersma and Vijay Janapa Reddi},
  booktitle={IEEE International Conference on Robotics and Automation (ICRA)}, 


When performing multiple computations of rigid body dynamics algorithms, GRiD provides as much as a 7.6x speedup over a state-of-the-art, multi-threaded CPU implementation, and maintains as much as a 2.6x speedup when accounting for I/O overhead.

Latency (including GPU I/O overhead) for N = 16, 32, 64, 128, and 256 computations of the gradient of forward dynamics for both the Pinocchio CPU baseline and the GRiD GPU library for various robot models (IIWA, HyQ, and Atlas). Overlayed is the speedup (or slowdown) of GRiD as compared to Pinocchio both in terms of pure computation and including I/O overhead.

To learn more about GRiD's performance results and to run your own benchmark analysis of GRiD's performance please check out our GRiDBenchmarks repository and our paper.

Instalation Instructions:

Install Python Dependencies

In order to support the wrapped packages there are 4 required external packages beautifulsoup4, lxml, numpy, sympy which can be automatically installed by running:

pip3 install -r requirements.txt

Install CUDA Dependencies

sudo apt-get update
sudo apt-get -y install xorg xorg-dev linux-headers-$(uname -r) apt-transport-https

Download and Install CUDA

Note: for Ubuntu 20.04 see for other distros

sudo mv /etc/apt/preferences.d/cuda-repository-pin-600
sudo apt-key adv --fetch-keys
sudo add-apt-repository "deb /"
sudo apt-get update
sudo apt-get -y install cuda

Add the following to ~/.bashrc

export PATH="/usr/local/cuda/bin:$PATH"
export LD_LIBRARY_PATH="/usr/local/cuda/lib64:$LD_LIBRARY_PATH"
export PATH="opt/nvidia/nsight-compute/:$PATH"


A GPU accelerated library for computing rigid body dynamics with analytical gradients







No releases published


No packages published