This page is currently maintained by Ying Lu.

In the following brief reviews, it is our intent to be as accurate as possible in my descriptions of the capabilities of the packages with respect to rigid body dynamics with intermittent unilateral contact. If you find errors, disagree with our assessment, know of any packages that we've missed, or know that some of the packages listed are no longer available, please let us know. Send email to Ying Lu.

This survey is limited to simulation packages that can handle systems with intermittent unilateral contacts

Open Source Packages

  • Bullet
    Bullet Physics is a professional open source collision detection, rigid body and soft body dynamics library. Bullet relaxes the friction model to make solution by projected Gauss-Seidel possible. Bullet's strength is in its recent developments for parallel computation. Collision detection and physics solutions can run entirely on a GPU without needing to communicate with a CPU. The recently released Bullet 2.80 includes a preview of the GPU OpenCL rigid body pipeline. Collision detection and physics have been optimized to run on multiple parallel processors. By using a special collision dispatcher, the code can activate parallel optimizations.

  • Chrono::Engine
    ProjectChrono is a set of open-source tools for mechanical simulations. The core of ProjectChrono is the Chrono::Engine C++ middleware, a powerful object-oriented set of libraries and their application program interface (API) can be freely used to develop simulation software. There are impressive simulation videos of many-body dynamics and they take advantage of the GPU and CPU parallelization. The physical contact model in Chrono::Engine is based a cone complementarity problem (CCP) with relaxation and stablization terms in the formulation.
    This engine is based on the work of Anitescu and Tasora. See Tasora's mechanical system simulation page for pictures and technical papers on the methods. The basic model is the complementarity problem similar to the engines described on this page, but it is modified to take the form of a second-order cone constrained optimization problem (SOCCOP). It is solved with a matrix-free method. They have simulated up to about 1,000,000 bodies coupled through contact on Tesla GPUs. To form the SOCCOP, the friction model is regularized with the undesirable side effect being the physical formation of gaps at all sliding contacts.

  • Dance
    Recently updated the binary version which is available for Windows with installer. The entire DANCE system is now open with all source code included. It supports the import/export of motion capture with easy plugin interface. Physical simulation of characters with dynamic control and pose-based dynamic control is available for DANCE. Besides, it has also been integrated with the Open Dynamics Engine(ODE).
    This system is still actively being developed.
    This is a multibody dynamics simulator based on SD/Fast and targeted at animation applications. It appears as though rigid-rigid contacts are supported through "actuator plug-ins," which can be implemented as a penalty method.

  • DART
    Dynamic Animation and Robotics Toolkits (DART) is an open source library for developing kinematic and dynamic applications in robotics and computer animation. DART uses generalized coordinates to represent articulated rigid body systems and computes Lagrange's equations derived from D'Alembert's principle to describe the dynamics of motion. The contact and collision are handled using an implicit time-stepping, velocity- based linear complementarity problem (LCP) to guarantee non-penetration, directional friction and approximated Coulomb's friction cone conditions. The LCP problem is solved by Lemke's algorithm.

  • dVC3d
    dVC3d is a physical simulation engine that focuses on accurate robotics application and testing of different cutting edge theories in physical simulation. Theoretically, it inherits the basic framework from dVC2Dd. Beside moving completely to 3D, dVC3d also integrates research works developed recently.

  • Gazebo
    Gazebo is a multi-robot simulator for outdoor environment. It has been used in the Darpa Robotics Challenge (DRC). It is capable of simulating a population of robots, sensors and objects, but does so in a three-dimensional world. It generates both realistic sensor feedback and physically plausible interactions between objects. Moreover, Gazebo is in the process to support other physics engines; right now, Gazebo supports 4 physics engines: ODE, Bullet , DART and Simbody

  • IBDS
    These comments are based on my reading of the 2006 paper, "Constraint-based collision and contact handling using impulses". In one time-step, this simulator identifies all imminent collisions and existing contacts. Then it executes two main steps. First, it iterates through all collisions to find impulses consistent with Newton's restitution model. Second it processes the sustained contacts, iteratively until it finds impulses that prevent penetration. The first part is done in a way very similar to what Mirtich implemented in Impulse. The second is similar to the Euler approximation of the dynamic equations used in velocity-level complementarity methods. The two iterative phases are essentially fixed-point iteration schemes applied in a Gauss-Seidel fashion. A benefit is that implementation as an any-time method is possible. The videos are impressive.

  • MBSim
    This project is being developed by the Center for Applied Mechanics at Technical University of Munich. It uses prox function formulations of the time-stepping subproblems to properly handle unilateral contacts with quadratic Coulomb friction. One drawback is that collision detection is not general. Pairs of geometric primitives are manually chosen for contact monitoring.

  • Moby
    Moby contains multiple joint constraints such as revolute, prismatic, spherical and so on. Besides, two optional convex solving methods incorporated in Moby are fast(active set QP-based) solver and accurate(interior-point quadratically constrained quadratic program-based) solver. Multiple integrator types are supported and thanks to the plugin of ODEPACK, the time stepper in Moby can now be variable step. Articulated bodies are supported using both independent coordinate and absolute coordinate representations.
    Moby uses the Anitescu/Potra time-stepping method augmented with Baumgarte stabilization for the bilateral constraints. No stabilization is used for the unilateral constraints, which means that unilateral constraints are added to the time-stepping subproblems as penetrations occur, and no attempt is made to correct these penetrations. This means that penetrations are controlled using an event-driven approach that adjusts the time steps to find the time when each contact occurs. Several LCP methods have been incorporated: Lemke, Lemke with Yamane's modification, and PATH.

  • Open Dynamics Engine
    ODE use the maximal coordinate solver: Projected Gauss Seidel (PGS), and the default maximum number of iterations in PGS solver is 40. Once it runs out of the maximum, the loop terminates with the solution from the last iteration. To my knowledge, there is no tracking of the best solution in the loop. Now Gazebo calls the PGS solver in ODE when solving the subproblems during each time step.
    The friction models are not Coulomb friction. The user can choose one of two approximations that make the time-stepping subproblem (an LCP) much easier to solve, but at the expense of some accuracy. There are several LCP solvers available in ODE. I like the documentation.
    Free software still under development from Russell Smith who worked at Math Engine. The method of integration is based on complementarity formulations of Stewart/Trinkle and Anitescu/Potra. The solver is based on Baraff's pivoting method. Collisions are handled following Mirtich's method.

  • RPISim
    RPI-MATLAB-Simulator (RPISim) is a physics engine and simulator in MATLAB. RPISim is aimed at building a modular simulator for both teaching and research. RPISim contains multiple joint constraints such as revolute, prismatic, spherical and so on. Collision detection, modeling, dynamics formulation, solution algorithms are independent modules, so RPISim provide users a flexible platform to simulate multibody dynamics. Besides, the linear complementarity problem, nonlinear complementarity problem and mixed complementarity problem are all supported in RPISim. Furthermore, there are pivoting and iterative algorithms to solve these problems. In order to fairly compare the performance of different algorithms, there is a Benchmark Problems for Multibody Dynamics (BPMD) framework. BPMD framework is open source and use the Hierarchical Data Format 5 (HDF5) BPMD database to compare the solution algorithms.

  • RBDL
    Rigid Body Dynamics Library(RBDL) performs the dynamics computation in a very efficient manner for models using generalized coordinates. It uses Featherstone's Spatial Algebra and allows for efficient evaluation of forward and inverse dynamics using the Articulated Body Algorithm and the Recursive Newton Euler Algorithm. RBDL also has implementation of methods to compute collisions and bilateral contact forces.

  • Simbody
    Simbody provides general multibody dynamics capability to solve Newton's second law in any set of generalized coordinates subject to any arbitrary constraint. Simbody uses an advanced featherstone-style formulation of rigid body mechanics to solve in O(n) time for any set of n genearlized coordinates.

  • Siconos Platform
    SICONOS is an open source scientific software primarily targeted at modeling and simulating nonsmooth dynamical system. There are some videos updated in granular terrain simulation on the web page. The directory hierarchy is well linked on the web page. Most of the algorithms are used to solve the linear complementarity problems.
    This project is still being actively developed. It would be nice if some videos were easily accessible.
    This software was developed for general non-smooth dynamical systems, including multi-rigid-body systems with unilateral contacts. Time-stepping is based on subproblems formulated as complementarity problems.

  • SOFA
    Simulation Open Framework Architecture (SOFA) is an open source (LGPL) software package, primarily intended for real-time dynamic simulation in the medical field. It's been around since 2006-2007, and is developed by a large team. SOFA includes cluster and GPU support, including using CUDA, and they are working on support for haptic devices. The software is very well organized. There are several collision checkers and dynamic models (flexible and rigid). It appears to have good support for finite element methods also.

  • Solfec
    Solfec is an implicit three-dimensional multibody frictional Contact Dynamics software. Both serial and parallel (MPI) versions are being actively developed. The non-smooth, velocity level frictional contact law (Signorini-Coulomb) is solved by means of a nonlinear Gauss-Seidel or a projected quasi-Newton method. Rigid, pseudo-rigid and finite element kinematics is included.
Closed Source Packages
  • Adams
    Simulation of unilateral contact is still via a penalty method.
    "Adams Solver" solves rigid body contact problems with a penalty method. It exhibited problems typical of penalty methods. For example, I tried rolling a faceted approximation of a uniform sphere on a plane and had to try many parameter settings before Solver returned a solution approximating the known exact solution.

  • Animats
    According to John Nagel of Animats, Falling Bodies, mentioned below, has been licensed to Havok for the past five years.
    The Animats web page is still under active development. Of interest is that they have patented at least two algorithms: (Patent 1) "Robots which can run up hills without slipping are usually covered by this patent." This patent appears to be based on a control method that reduces the magnitudes of the friction forces needed to prevent foot slip. (Patent 2) "This broad patent covers most spring/damper character simulation systems. If it falls, it has joints, it looks right, and it works right, it's usually covered by our patent." My interpretation of the patent is that they use a penalty method that begins responding in before the bodies are in contact and grows quickly to ensure that penetration never occurs.
    The Falling Bodies software takes a spring/damper approach with a Featherstone-type approach to articulated characters, but with very careful handling of the details (SDFast is used to generate C-code from Featherstone's algorithm). It slows down on difficult collisions, but eventually grinds its way through them.

  • Cinema 4D Dynamics
    Animations are done by key-framing, which would imply that there are no built-in rigid body dynamics algorithms. I was unable to find impressive videos that I saw 8 years ago here.
    This software simulates rigid body systems and other flexible systems like cloth. Only $500. This package seems to be an equal (on paper) to "Total Havok." Excellent videos. There is no information about the method used for rigid body dynamics.

  • DynaWiz
    DynaWiz has been updated to allow unilateral contacts to occur during run-time. Here is a quote from the web page about solution the complexity of their time-stepping method: "Order(N + sum(n_i^3)), where N = number of bodies, and n_i^3 = number of flexible modes for the i-th body." The implication here is that unilateral contacts are treated as permanently connected. If an LCP (or NCP) formulation were employed, then there should be another term in the complexity expression; something like O(n_c^3), where n_c is the number of unilateral contacts.
    DynaWiz formulates multibody dynamics in Lagrangian form, and provisions are made for event detection. However, in the introductory web pages, there is no description of how rigid-rigid contacts are handled. A direct communication with CDI indicated that DynaWiz does not support unilateral rigid contacts. The user would have to insert his own solvers.

  • Havok Physics
    This system is still actively being developed. There are many interesting videos with flexible objects and fluid flow. Havok is free for non-commercial use.
    A dynamics engine geared toward rigid body dynamics for real-time virtual environments. The package "Total Havok" adds flexible bodies and fluid dynamics. The demos are as impressive as any I've seen, but there is no indication of the simulation method used.

    From an engineer at LMS, I learned that the user can specify a linear stiffness and damping model Kelvin-Voigt) to generate the contact force or use a Hertzian contact model. The API will return depth of penetration, velocity, normal, etc. for advanced users who want to create their own penalty-based contact force model.
    A full-blown commercial package similar to MDI Adams. Intermittent contacts are handled, but I don't yet know the method used. However, there is mention of using DAE methods for integration, which implies that they manage contact state transitions by monitoring contact forces (as Haug did in the original DADS package).

  • Maya
    Maya is a comprehensive 3D animation software, which offers a comprehensive creative feature set for 3D computer animation, modeling, simulation, rendering, and compositing on a highly extensible production platform. I got to know Jos Stam at the Banff center in Canada for a workshop on computational contact mechanics. The unified dynamics framework Nucleus in Jos' presentation is based on particles with constraints. There are impressive videos with simulation on cloth, rigid bodies and liquids; All of the dynamics are unified in a single solver.

  • PhysX
    You can easily find lots of info on PhysX on line. What you won't find is that when Ageia originally developed the engine, it was based on the impulse-velocity time-stepping formulations of Stewart-Trinkle and Anitescu-Potra. So friction and intermittency of contact was handled with the framework of complementarity problems. I don't know how much of this has been retained in the Nvidia product.

    This package implements a penalty method using a polygonal contact model developed by Gerhard Hippman. Contact forces can be specified as functions of penetration volumes, depths, elastic moduli, material deformation damping constants, Poisson's ratio, etc.

  • Sonar Simulation
    Sonar software consists of Sonar_LAB an Sonar_SIM. Sonar_LAB is a tool to create 3-dimensional multibody dynamic models using C#; Sonar_SIM is used to execute the simulation of the models created by means of sonar-3D-LAB. Sonar-SIM supports the multiprocessing standard 'openMP', and it comes with different licenses. The frictional contact between two rigid bodies is solved using a spring-damping system, without formulation of the complementarity problems.

  • Tokamak
    Tokamak Game Physics SDK is a high performance real-time physics library designed specially for games. Tokamak features a unique iterative method for solving constraint, which allows developers to make the trade-off between accuracy. Besides, Tokamak supports a variety of joint types and joint limits and provides a very realistic friction model.

  • Umbra
    Umbra development has intensified. Michael Skroch, manager of the group developing Umbra, said, "I have been focusing on Umbra being useful for the nexus of physical-cyber-behavior concepts in a 3D embodied environment. We've started work on parallelizing Umbra and providing multi-thread enhancements. We also are working with GPUs to improve speed."
    Umbra is a general simulation and visualization environment developed by Fred Oppel and Eric Gottlieb at Sandia National Laboratories. It contains a rigid body dynamics module developed by Eric Gottlieb with technical guidance from Florian Potra and Jeff Trinkle. The time-stepping algorithm is based on the Stewart-Trinkle LCP formulation (in terms of velocities and impulses). All the videos on this web page were produced with Umbra. Even though there is currently no impact law is implemented, bouncing behavior can be observed in the animations. This is simply a side effect of the constraint stabilization in the Stewart-Trinkle algorithm. Many enhancements are underway.

  • visual Nastran 4D
    This product is available, but I found much less information about it than other MSC products.
    Formerly Working Model. The integration method for rigid body dynamics is a penalty method. Even though it probably exhibits the usual problems that plague penalty methods, vN4D ran right "out of the box" on a problem in which three parts with about 1500 facets each were dropped onto a plane such that they would collide with each other. The API does not provide access to contact point locations and normals, but is schedule to in the next release - Q1 of 2002.

  • Vortex
    Vortex 5.1 with the new Vortex Editor puts the vehicles, robots, heavy equipment and more into high-fidelity synthetic environments for operator training, mission rehearsal, virtual prototyping and testing.
    Version 3 of Vortex will include "scaled" box friction, which approximates a quadratic friction cone with a 4-sided friction pyramid (Chris Funk, CMLabs).
    In the PackBot video, I noticed penetration between the PackBot and the ground (especially when the Bot moves up and over a curb. This can come from an offset in the geometry used for collision detection and that used for visual rendering, Or it can come from using a penalty approach for contact force resolution.
    Specialized for rigid body dynamics with unilateral, frictional contacts. However, dry friction does not obey Coulomb's Law. There are three choices, zero friction, infinite friction, and "box" friction. Box friction is simple limits on the tangential force values in two directions - no dependency on the normal load. A first-order semi-implicit time-stepper is used. The contact constraints are likely to be formulated as a complementarity problem, since it is possible to get a warning about cycling during constraint solution. The solver is at least partially based on algorithms to solve complementarity problems. The demos are impressive.
Defunct Packages
  • Abdula
    This was a link to Abdula on Francois' page at TU Wien (Technical University of Vienna), but it is broken now.
    Francios Faure's Abdula can do some pretty amazing animations; up to 64,000 frictionless spheres dropped into a bowl. The simulation method is not published, but is related to the "optimization-based animation" of Schmidl and Milenkovic. Abdula is no longer being improved as Francios is developing a more general and flexible library.

  • AERO
    No new information.
    Refers to itself as a physically-based animation system. This software uses a penalty method to calculate the contact forces. It also uses a "fixed set of bodies instead of triangular meshes." Complementarity theory and Baraff's method are mentioned as worthy goals that are not implemented.

  • DynaMechs
    I can't find anything about unilateral contacts on the web page, but I learned from David Orin that unilateral contacts for a walking machine were implement using a penalty method.
    Free software being developed at Ohio State University. Dynamics of mechanisms with and without closed loops. Contact force models are being developed to support applications such as walking robots. There was no mention of rigid-rigid contacts - probably not yet included.

  • Impulse
    Nothing new here.
    Brian Mirtich's Impulse does rigid body simulation with nothing but collisions. A hybrid version was developed to combined impulse with joint constraints. While at MERL Mirtich added a "time-warp" feature to avoid the crippling bottleneck caused by synchronous processing for large numbers of bodies.

  • Simulation and Active Interfaces
    This project is no longer under development and the link is broken
    A rigid body dynamics engine developed by that is based on the algorithms of Featherstone (dynamics with bilateral constraints), Mirtich (collision impulse response), and Baraff (contact transitions e.g., sticking to sliding). A haptic interface allows real-time interaction with a virtual environments as long as the number of degrees of freedom and number of steady contacts is not too large.