Artificial Intelligence for Kinematics, Dynamics, and Optimization


AIKIDO - AI for KIDO Build Status codecov Codacy BadgeDOI

⚠️ Warning: AIKIDO is under heavy development. These instructions are primarily for reference by the developers.

AIKIDO is a C++ library, complete with Python bindings, for solving robotic motion planning and decision making problems. This library is tightly integrated with DART for kinematic/dynamics calculations and OMPL for motion planning. AIKIDO optionally integrates with ROS, through the suite of aikido_ros packages, for execution on real robots.

Building from Source


AIKIDO depends on ROS. You should install ROS by adding the ROS repository to your sources.list as follows. We encourage users to install noetic with at least the following packages:

$ sudo apt install ros-noetic-actionlib ros-noetic-geometry-msgs ros-noetic-interactive-markers ros-noetic-roscpp ros-noetic-std-msgs ros-noetic-tf ros-noetic-trajectory-msgs ros-noetic-visualization-msgs

AIKIDO also depends on CMake, Boost, DART (version 6.8.5 or above), OMPL, yaml-cpp, tinyxml2, pr-control-msgs, libmicrohttpd, and the Python development headers (python-dev on Debian systems). DART and AIKIDO both make heavy use of C++14 and require a modern compiler.

On Ubuntu Focal using CMake

You should install the ROS packages as described above to build all the ROS-dependent AIKIDO components (e.g., aikido-control-ros).

Install the other dependencies:

$ sudo add-apt-repository ppa:dartsim/ppa
$ sudo add-apt-repository ppa:personalrobotics/ppa
$ sudo apt-get update
$ sudo apt-get install cmake build-essential libboost-filesystem-dev libdart6-optimizer-nlopt-dev libdart6-utils-dev libdart6-utils-urdf-dev libmicrohttpd-dev libompl-dev libtinyxml2-dev libyaml-cpp-dev pr-control-msgs

Once the dependencies are installed, you can build and install AIKIDO using CMake:

$ mkdir build
$ cd build
$ cmake ..
$ make  # you may want to build AIKIDO using multi-core by executing `make -j4`
$ sudo make install

AIKIDO includes several optional components that depend on ROS. While we suggest building AIKIDO in a Catkin workspace (see below) to enable the ROS components, it is also possible to build those components in a standalone build. To do so, source the setup.bash file in your Catkin workspace before running the above commands, e.g.:

$ . /path/to/my/workspace/setup.bash

On Ubuntu Focal using Catkin

It is also possible to build AIKIDO as a third-party package inside a Catkin workspace. To do so, clone AIKIDO into your Catkin workspace and use the catkin build command like normal.

If you are using the older catkin_make command, then you must build your workspace with catkin_make_isolated. This may dramatically increase your build time, so we strongly recommend that you use catkin build, which is provided by the catkin_tools package, if possible.

On macOS using CMake

Please install Homebrew as described above, then you can easily install the dependencies as follows:

$ cd <aikido_directory>
$ brew bundle

Once the dependencies are installed, you can build and install AIKIDO using CMake:

$ cd <aikido_directory>
$ mkdir build
$ cd build
$ cmake ..
$ make  # you may want to build AIKIDO using multi-core by executing `make -j4`
$ sudo make install

Code Style

Please follow the AIKIDO style guidelines when making a contribution.


AIKIDO is licensed under a BSD license. See LICENSE for more information.


AIKIDO is developed by the Personal Robotics Lab in the Paul G. Allen School of Computer Science and Engineering at the University of Washington. The library was started by Michael Koval (@mkoval) and Pras Velagapudi (@psigen). It has received major contributions from Shushman Choudhury (@Shushman), Ethan Gordon (@egordon), Brian Hou (@brianhou), Aaron Johnson (@aaronjoh), Jennifer King (@jeking), Gilwoo Lee (@gilwoolee), Jeongseok Lee (@jslee02), and Clint Liddick (@ClintLiddick). We also would like to thank Michael Grey (@mxgrey) and Jeongseok Lee (@jslee02) for making changes to DART to better support AIKIDO.

  • Add wrapper for OMPL path simplifier

    Add wrapper for OMPL path simplifier

    This introduces a way to simplify and shorten paths obtained from the planners used in AIKIDO using OMPL methods.

    AIKIDO Planner -> untimed trajectory -> simplifyOMPL -> simplified and shortened untimed trajectory.

    -> The feature has been currently introduced same place as the planning methods although really a post-processing step. Is there a better place for this than here, currently?

    opened by aditya-vk 35
  • Created aikido_perception package

    Created aikido_perception package

    This is the first attempt at a perception module for AIKIDO.

    • Introduction of aikido_perception as a package
    • Abstract class in PerceptionModule.hpp
    • Implementation in AprilTagsModule.hpp/cpp

    This change is Reviewable

    opened by Shushman 29
  • Initial draft for SampleableRegion, IKAdapter, TSR.

    Initial draft for SampleableRegion, IKAdapter, TSR.

    @psigen @mkoval @cdellin This is initial draft of above classes based on discussion with @mkoval last Friday. It's probably not a working code yet, but since it involves API changes and moving namespaces, I thought I'd have it checked early on. Please add any comments!

    P.S.: Not familiar with C++11 convention so it'd probably have some mistakes there too.. =P

    opened by gilwoolee 29
  • Feature/kinbodyparser


    A first pass at a Kinbody Parser under aikido::util. Points to note:

    1. Only works if the KinBody has one Body element with 1 or 2 Geom elements, and Render and Data both defined, and refer to some file.
    2. I've mostly followed the template in SkelParser
    3. A problem - The plastic bowl and glass are two files that are read in just fine, but I get a strange error (originating from dart::dynamics::MeshShap::loadMesh) upon trying to load say the Pop tarts or kinbody. The error message is:
    Warning [MeshShape.cpp:349] [MeshShape::loadMesh] Failed loading mesh 'package://pr_ordata/data/objects/kinova_tool.stl 0.1'.
    Error [KinBodyParser.cpp:423] [KinBodyParser] Fail to load model[kinova_tool.stl 0.1].

    Sometimes, even without the error message, the Pop tarts looks like:


    This change is Reviewable

    opened by Shushman 25
  • Template Rn for dimension to exploit performance of fixed-size Eigen objects

    Template Rn for dimension to exploit performance of fixed-size Eigen objects


    • [x] Explicitly instantiates for frequently used dimensions
    • [x] Use extern template to force the compiler not to instantiate for the explicitly instantiated types
    • [x] Decide name: template <int N> class Rn vs template <int N> class R (I prefer R<N>)
    • [x] Support dynamic size

    Resolves #152

    opened by jslee02 24
  • Use forward declaration of smart pointers

    Use forward declaration of smart pointers

    This PR moves the declaration of smart pointers to separate headers to avoid the circular dependencies.

    Before creating a pull request

    • [x] Format code with make format

    Before merging a pull request

    • [x] Set version target by selecting a milestone on the right side
    opened by jslee02 17
  • Yaml extension for Eigen::Matrix and std::unordered_map

    Yaml extension for Eigen::Matrix and std::unordered_map

    Adds YAML parser for Eigen datatype, originally implemented by @mkoval . Copied from kenv. Allows operations such as<Eigen::VectorXd>,<Eigen::Isometry3d> , etc..

    opened by gilwoolee 17
  • Adding an abstract BarrettHandPositionCommandExecutor class

    Adding an abstract BarrettHandPositionCommandExecutor class

    This PR adds BarrettHandPositionCommandExecutor and renames several classes. This is necessary/convenient to have a non-simulation counterpart ros::RosBarrettHandPositionCommandExecutor which has the same execute method signature as the existing sim-mode-executor.

    • adds an abstract class BarrettHandPositionCommandExecutor which contains execute method for four finger goal positions (3 primal, 1 spread).
    • renames existing Barrett*Executor classes to SimBarrett*Executor
    • removes collideWith param from their execute method to match the abstract class's execute signature
    • addscollideWith to the contructors for SimBarrett*Executor classes
    • addssetCollideWith methods to SimBarrett*Executor classes

    One question for @mkoval : shouldn't we expose step (or spin) method for all Executors, including the higher level abstract classes? (applies to #149 as well)

    opened by gilwoolee 15
  • Function to convert trajectory_msgs::JointTrajectory into aikido::trajectory::Spline

    Function to convert trajectory_msgs::JointTrajectory into aikido::trajectory::Spline

    This PR branches from #111. I have one question. It seems like the use of DOF and Joint is mixed here. convertJointTrajectory asks for _space->getNumSubSpaces() which would return the number of Joints, but then considers these as DOFs. This would work fine (except for name-matching) if all joints are single-dof joints. Is that the case since we're using JointTrajectory, not MutliDOFJointTrajectory?

    @mkoval @ClintLiddick Please confirm. If that's the case, I'll change the variable names, docstring, and name-checking part to clarify this.

    opened by gilwoolee 15
  • TrajectoryExecutor interface

    TrajectoryExecutor interface

    This PR contains:

    • TrajectoryExecutor
    • TrajectoryResult
    • KinematicSimulationTrajectoryExecutor
    • Tests for KinematicSimulationTrajectoryExecutor.

    This change is Reviewable

    opened by gilwoolee 15
  • Code format: util

    Code format: util


    • Updated the style configuration to be close to the C++ style in as much as possible.
    • Applied it to util's header(todo) and source files as the first stage
    • Setup CI to check the format



    • [x] breaking-constructorInitializers-before-comma
    // Good!
    : mSeq(seq)
    , mN(-1)
    , mFinalIter(false)
    // Bad
    : mSeq(seq),
    • [x] Install clang-format-3.8 in pr-cleanroom
    opened by jslee02 14
  • Remove bug where Kunz hangs on empty trajectory

    Remove bug where Kunz hangs on empty trajectory

    Previously, in the case of an empty trajectory (which is possible for an Offset planner with 0 offset or a configuration planner with goal == start), the resulting trajectory was length 0.

    In this case, any postprocessor should return a valid (but empty) trajectory.

    However, Kunz's Trajectory class initially timed the trajectory using the velocity without checking for 0 velocity. If there is 0 velocity but non-0 position, the trajectory is invalid (this should never happen). But if there is 0 velocity AND 0 change in position, the trajectory is valid but empty, and Kunz shouldn't perform the division (which results in a NaN endTime, which in turn leads to a VERY LARGE sequence of waypoints when naively constructed with aikido::common::StepSequence, which in turn causes the program to loop nearly infinitely).

    In addition, the Robot class has been modified to gracefully handle valid and empty trajectories (namely: not executing them).

    Before creating a pull request

    • [ N/A ] Document new methods and classes
    • [x] Format code with make format

    Before merging a pull request

    • [x] Set version target by selecting a milestone on the right side
    • [ ] Summarize this change in
    • [x] Add unit test(s) for this change
    opened by egordon 1
  • Controller Switching through RosRobot

    Controller Switching through RosRobot

    Builds on top of #614. Adds corresponding controller operations (load, start, stop) to the executors operations (register, activate, deactivate). Corresponding hardware mode switching takes place if a joint mode controller is specified.

    Before creating a pull request

    • [ ] Document new methods and classes
    • [ ] Format code with make format

    Before merging a pull request

    • [ ] Set version target by selecting a milestone on the right side
    • [ ] Summarize this change in
    • [ ] Add unit test(s) for this change
    opened by RKJenamani 0
  • RosJointStateClient is a bit of a mess

    RosJointStateClient is a bit of a mess

    There are a few key issues with the RosJointStateClient:

    (1) There's no reason to lock the mSkeleton mutex in spin, since we don't read or write from it at all.

    (2) There is not reason to store the mSkeleton pointer anyway, since we never use it.

    (3) We should decide on a better interface. Either [1] we should pass in a MetaSkeletonPtr (assuming the parent skeleton is already locked) and set the corresponding (subset of) DoFs directly, or [2] we should just return a copy of the buffer as a map from DoF name to position, and have the client set their own MetaSkeleton accordingly.

    enhancement good first issue 
    opened by egordon 0
  • Support for URDF Mimic Joints

    Support for URDF Mimic Joints

    The URDF format does not support cycles in the Joint Tree (for example, 4- or 5-bar linkages). Instead, the kinematics/dynamics of these relationships are specified using the <mimic> joint declaration, where the position of a joint is set to be some linear function of another joint (i.e. joint2 = m * joint1 + offset). See

    The URDF loader in DART ( handles this by registering the joint as normal, and then just setting the ActuatorType to "MIMIC", which is used during dynamic simulation to set the set-point of a given joint based on the position of its corresponding mimic joint.

    However, Aikido does not use DART's dynamic simulation. We set the positions/velocities of joints ourselves to do Kinematic simulation and collision detection. Therefore, there is no obvious way to handle mimic joints. And the additional Degrees of Freedom that are registered lead to a StateSpace that doesn't reflect the actual configuration space of the robot.

    This makes it impossible to plan and execute a trajectory on, for example, ADA's grippers, which have 4-bar (Gen2) or 5-bar (Gen3) linkages respectively.

    Existing workaround: in the URDF, set the joint type of the mimic joint to "fixed". This allows the StateSpace to be constructed only considering the base joint. However, this forces the gripper to go into collision with itself when closed. So you need to disable all self-collision in the hand. This works, and is what we use for ADA Gen2, but it leads to a non-realistic collision model for the gripper, which affects the ability of planning algorithms to accurately plan around objects in the environment.

    How We Can Fix This: Update the MetaSkeletonStateSpace Object

    1. When creating the state space, make sure that the mimic joints are not registered as joint sub-spaces, and update the Properties object accordingly (i.e. the number of DoFs in the properties object = MetaSkeleton Dofs - Mimic Dofs)
    2. For convertStateToPositions and setState, do the mimic multiplier+offset calculates to set the positions of the MetaSkeleton (or, respectively, return the positions Eigen Vector) accordingly.
    3. for convertPositionsToState, accept an Eigen Vector of either the length of the number of true DoFs, or the length of the number of MetaSkeleton Dofs (as a utility for passing in MetaSkeleton.getPositions()). If the latter, check to make sure that the mimic constraints are upheld (to appropriate float precision) before creating the state object.
    4. Make sure that all relevant calls for setting the state of the MetaSkeleton (esp. in collision, control, and robot) do it through the statespace rather than calling setPositions directly
    opened by RKJenamani 0
  • Add planWithEndEffectorTwist

    Add planWithEndEffectorTwist

    Currently, planToEndEffectorOffset functions only perform end-effector translations.

    But the user may conceivably want to perform rotations as well.

    There is an existing PR that is closed for now, but is fairly close to being done.

    enhancement help wanted good first issue 
    opened by egordon 1
  • Add util function to aikido::io to create a CompositeResourceRetriever

    Add util function to aikido::io to create a CompositeResourceRetriever

    Currently, we almost exclusively use the CatkinResourceRetriever, which only accepts the package:// schema.

    There are other ResourceRetrievers we can use that can accept other schemas (e.g. file://, dart://).

    DART has a CompositeResourceRetriever object that is more flexible, delegating to individual retrievers based on the schema (or based on precedence, i.e., try one retriever, and then move on to another if the first fails).

    To simplify the process of using ResourceRetrievers, we can add a utility function to the aikido::io module that returns a CompositeResourceRetriever that can handle at least package://, file://, dart:// and potentially no schema (i.e. file path relative to execution point) to use as a default.

    enhancement good first issue 
    opened by egordon 0
  • v0.4.0(Aug 27, 2020)

  • v0.3.1(Jun 1, 2020)

  • v0.3.0(May 22, 2020)

    • Common

      • Fixed bug in StepSequence::getMaxSteps(): #305
      • Fixed bug in StepSequence iterator: #320
      • Cleaned up doxygen errors: #357
      • Fixed bug in compiling with Boost 1.58 on Kinetic + Xenial: #490
      • Fixed bug in Interpolated::addWaypoint(): #483
      • Fixed bug in VanDerCorput sequence generator to handle non-unit span: #552
      • Updated to C++14 Standard: #570
    • Distance

      • Added methods to rank configurations based on specified metric: #423
      • Added weights as optional parameter to rankers: #484
      • Updated constness of return type of SE2::getStateSpace(): #536
    • State Space

      • Refactored JointStateSpace and MetaSkeletonStateSpace: #278
      • Added methods for checking compatibility between DART objects and state spaces: #315
      • Added flags to MetaSkeletonStateSaver to specify what to save: #339
      • Fixed bug in the representation of SO(2) statespace: #408
      • Fixed const correctness of StateHandle::getState(): #419
      • Fixed hidden compose function (in-place version): #421
      • Added clone functionality to StateSpace: #422
      • Used const StateSpaces everywhere: #429
      • Changed the SE(2) space representation to [x,y,theta]: #458
    • Constraint

      • Added SequentialSampleable: #393
      • Changed deprecated DART call in InverseKinematics: #524
    • Control

      • Fixed CollisionGroup bugs in Hand executors: #299
      • Rewrote executors for faster-than-realtime simulation: #316, #450
      • Introduced uniform and dart namespaces: #342
      • Removed Barrett-specific hand executors: #380
      • Supported canceling in-progress trajectories: #400
    • Perception

      • Added integrated PoseEstimatorModule: #336
      • Added voxel grid perception module: #448
      • Added YAML communication between PoseEstimatorModule and third-party perception algorithms: #497
      • Made AssetDatabase key required for Marker text: #508
    • Trajectory

      • Added B-spline trajectory: #453
      • Added trajectory utility functions: #462
      • Fixed toR1JointTrajectory to copy Waypoints with their time information: #510
      • Removed incorrect Spline to Interpolated conversions: #511
      • Updated findTimeOfClosestStateTrajectory to use StateSpace Distance Metric: #543
      • Add SO2 handling in spline conversions: #546
    • Planner

      • Check that all planning problems only hold ScopedStates: #569
      • Make all DART planners take MetaSkeleton, and add adapter for turning planners into DART planners: #437
      • Added parabolic timing for linear spline #302, #324
      • Fixed step sequence iteration in VFP: #303
      • Refactored planning API: #314, #414, #426, #432
      • Added flags to WorldStateSaver to specify what to save: #339
      • Changed interface for TrajectoryPostProcessor: #341
      • Planning calls with InverseKinematicsSampleable constraints explicitly set MetaSkeleton to solve IK with: #379
      • Added a kinodynamic timer that generates a time-optimal smooth trajectory without completely stopping at each waypoint: #443
      • Fixed segmentation fault on 32-bit machines in vector-field planner: #459
      • Updated interface to OMPL planners to follow the style of the new refactored planning API: #466
      • Added convenience function for converting SO(2) trajectories to R1 trajectories, support for postprocessing SO(2) trajectories: #496
      • Used ConfigurationRanker in TSR planners: #503
      • Returned Interpolated trajectories from VFP: #513
      • Added support for taking state snapshots with list of skeleton names: #523
    • Robot

      • Added Robot, Manipulator, Hand interfaces, and ConcreteRobot, ConcreteManipulator classes: #325, #392
      • Added Kunz timer to Robot class: #505
      • Made ConcreteRobot limit functions public: #556
    • RViz

      • Fixed bug of not joining Viewer threads when stopping auto-update: #463
      • Fixed bug of not passing full file path to RViz when MeshShape is used: #518
      • Merged WorldInteractiveMarkerViewer into InteractiveMarkerViewer, removing the former: #520
      • Fixed bug of not removing SkeletonMarkers of skeletons removed from the associated World: #560
    • IO

      • Added loadSkeletonFromURDF convenience function: #388, #401
      • Added methods for caching and retrieving trajectories: #541
    • Build & Testing & ETC

      • Fixed Eigen memory alignment issues on 32bit Ubuntu: #368
      • Defined optional dependencies: #376
      • Fixed compilation bug with Eigen 3.3.5: #452
      • Updated gtest version to 1.8.1: #478
      • Added DART 6.7 support: #480
      • Fixed use of dart::common::make_unique for C++14 enabled compilers: #481
      • Changed to use own build script for GoogleTest: #485
      • Added aikido::common::make_unique wrapper: #532
      • Manually generated (minimal) Python bindings: #499
    Source code(tar.gz)
    Source code(zip)
  • v0.2.0(Jan 10, 2018)

    0.2.0 (2018-01-09)

    • State Space

      • Moved MetaSkeletonStateSpaceSaver implementation to src: #273
    • Constraint

      • Added methods for removing groups from NonColliding constraints: #247
      • Renamed NonColliding to CollisionFree: #256
      • Added TestableOutcome class: #266
    • Perception

      • Added RcnnPoseModule: #264
    • Planner

    • RViz

      • Added WorldInteractiveMarkerViewer: #242
      • Added TrajectoryMarker: #288
    • IO

      • Added support for new ErrorStr API in tinyxml2 6.0.0: #290, #295
    • Build & Testing & ETC

      • Changed to use size_t over std::size_t: #230
      • Included test code to formatting code list: #239
      • Fixed RViz component dependencies: #253
    Source code(tar.gz)
    Source code(zip)
  • v0.1.0(Oct 3, 2017)

    • Common

      • Added VanDerCorput::getLength(): #223
      • Added ExecutorThread and ExecutorMultiplexer: #151
      • Changed splitEngine() to set default numOutputs to 1: #214
    • State Space

      • Added MetaSkeletonStateSpaceSaver: #184, #219
      • Added WeldJoint: #146
      • Improved real vector space classes to take advantage of Eigen's fixed-size objects: #159
    • Constraint

      • Added SE2BoxConstraint: #135
      • Added satisfiable tolerance parameter to TSR constructor: #180
      • Added ConstantSampler: #146
      • Renamed SO2Sampleable to SO2UniformSampler: #224
    • Perception

      • Added simulation world env to ApriltagsModule: #156
    • Planner

      • Added parabolic smoother: #206
      • Added wrapper for OMPL path simplifier: #164
      • Added support OMPL 1.2.0 and above: #139
      • Changed to SnapePlanner to return nullptr when planning fails: #201
      • Refactored parabolic timer: #206
    • IO

      • Added KinBody parser: #102
      • Improved yaml extension: #175, #200
    • RViz

      • Added TSR visualizer: #136
      • Made FrameId a variable: #183
      • Fixed inconsistent function signature: #222
    • Control

      • Added toSplineJointTrajectory() that can controls only specifying joints: #217
      • Added RosPositionCommandExecutor: #173
      • Added BarretthandPositionCommandExecutor: #166
      • Added RosJointStateClient: #150
      • Added trajectory conversions between Aikido's and ROS's: #147, #149
      • Improved RosTrajectoryExecutor to use helper function for waiting for action server: #192
      • Improved (~)Executor::step() not to lock: #182
      • Fixed renaming sping to step: #189
      • Fixed to work on real hardware: #216
      • Removed StateSpace from RosTrajectoryExecutor: #190
    • Build & Testing & ETC

      • Added Findinteractive_markers.cmake: #198
      • Improved to build without warnings: #114, #143
      • Improved to enforce to follow code formatting: #153, #167, #172, #168, #170, #171, #191, #207, #211
      • Switched to codecov for online code coverage reporting: #208
      • Increased the required minimum version of DART to 6.2: #210
      • Changed to test Aikido for both of release and debug modes, and on macOS: #195
      • Splitted util namespace into common and io: #225
      • Fixed build issues on macOS: #138
    Source code(tar.gz)
    Source code(zip)
Personal Robotics Laboratory
Personal Robotics Laboratory
Source code for the data dependency part of Jan Kossmann's PhD thesis "Unsupervised Database Optimization: Efficient Index Selection & Data Dependency-driven Query Optimization"

Unsupervised Database Optimization: Data Dependency-Driven Query Optimization Source code for the experiments presented in Chapter 8 of Jan Kossmann's

Jan Koßmann 4 Apr 24, 2022
Code for Stepper Motors and Robot Kinematics YouTube course

Code for YouTube course: Stepper Motors and Robot Kinematics: Theory and Practice on STM32 This repo contains the code for my YouTube course Stepper M

null 4 Jan 6, 2022
Combining Sealighter with unpatched exploits to run the Threat-Intelligence ETW Provider

Sealighter-TI Combining Sealighter with unpatched exploits and PPLDump to run the Microsoft-Windows-Threat-Intelligence ETW Provider without a signed

pat_h/to/file 58 Dec 26, 2022
Desenvolvimento da inteligência artificial de um barco pesqueiro.

Projeto Final da Disciplina de Introdução às Técnicas de Programação. Desenvolvido por: Stefane de Assis e Débora Everly Introdução O Projeto desenvol

StefWolf Sensitivel Lotus Flower 4 Feb 15, 2022
Improved version of real-time physics engine that couples FEM-based deformables and rigid body dynamics

Enhanced version of coupled FEM and constrained rigid body simulation Description This little playground aimed to test our Conjugate Gradients based M

Andrey Voroshilov 25 Apr 11, 2022
VID-Fusion: Robust Visual-Inertial-Dynamics Odometry for Accurate External Force Estimation

VID-Fusion VID-Fusion: Robust Visual-Inertial-Dynamics Odometry for Accurate External Force Estimation Authors: Ziming Ding , Tiankai Yang, Kunyi Zhan

ZJU FAST Lab 86 Nov 18, 2022
OpenFOAM is a free, open source computational fluid dynamics (CFD) software package

acousticStreamingFoam About OpenFOAM OpenFOAM is a free, open source computational fluid dynamics (CFD) software package released by the OpenFOAM Foun

Bruno 3 Oct 28, 2022
Simple, differentiable rigid body dynamics

Quark Quark is intended to be a simple differentiable rigid body dynamics library. For the time being it is starting out as a ground-up rewrite of RBD

Pedro Morais 4 Nov 23, 2021
Event-driven molecular dynamics simulations for hard spheres

Event-driven molecular dynamics code for hard spheres This is an event-driven molecular dynamics (EDMD) code for hard spheres. It uses neighbor lists

null 11 Nov 14, 2022
A CUDA-accelerated cloth simulation engine based on Extended Position Based Dynamics (XPBD).

Velvet Velvet is a CUDA-accelerated cloth simulation engine based on Extended Position Based Dynamics (XPBD). Why another cloth simulator? There are a

Vital Chen 39 Dec 21, 2022
LightAIMD - A lightweight ab initio molecular dynamics simulation program

LightAIMD - Ubuntu 20.04 Build LightAIMD is a lightweight AIMD (ab initio molecular dynamics) simulation program for simulating aperiodic molecular sy

Microsoft 25 Nov 27, 2022
Mod - MASTERS of DATA, a course about videogames data processing and optimization

MASTERS of DATA Welcome to MASTERS of DATA. A course oriented to Technical Designers, Technical Artists and any game developer that wants to understan

Ray 35 Dec 28, 2022
Wolfram Language interface to the Gurobi numerical optimization library

GurobiLink for Wolfram Language GurobiLink is a package implemented in Wolfram Language and C++ using LibraryLink that provides an interface to the Gu

Wolfram Research, Inc. 16 Nov 3, 2022
OptimLib: a lightweight C++ library of numerical optimization methods for nonlinear functions

OptimLib OptimLib is a lightweight C++ library of numerical optimization methods for nonlinear functions. Features: A C++11 library of local and globa

Keith O'Hara 618 Dec 27, 2022
DG-Mesh-Optimization - Discontinuous Galerkin (DG) solver coupled with a Quasi-Newton line-search algorithm to optimize the DG mesh.

Date written: December 2020 This project was pursued as my final project for MECH 579 (Multidisciplinary Design Optimization) at McGill University, ta

Julien Brillon 8 Sep 18, 2022
HESS (Hyper Exponential Space Sorting) is a polynomial black-box optimization algorithm, that work very well with any NP-Complete, or NP-Hard problem

The original HESS (Hyper Exponential Space Sorting) is a polynomial black-box optimization algorithm, that work very well with any NP-Complete, or NP-Hard problem, at 2021 thanks to suggestions of Daniel Mattes, work like a complete algorithm.

SAT-X 3 Jan 18, 2022
Optimization-Based GNSS/INS Integrated Navigation System

OB_GINS Optimization-Based GNSS/INS Integrated Navigation System We open-source OB_GINS, an optimization-based GNSS/INS integrated navigation system.

i2Nav-WHU 289 Jan 7, 2023
GLSL optimizer based on Mesa's GLSL compiler. Used to be used in Unity for mobile shader optimization.

GLSL optimizer ⚠️ As of mid-2016, the project is unlikely to have any significant developments. At Unity we are moving to a different shader compilati

Aras Pranckevičius 1.6k Jan 3, 2023
null 313 Dec 31, 2022