Ly0n / awesome-robotic-tooling, Hacker News

Ly0n / awesome-robotic-tooling, Hacker News





          Just a bunch of powerful robotic resources and tools for professional robotic development with ROS in C and Python.           




Just a bunch of powerful robotic resources and tools for professional robotic development with ROS in C and Python.

Lets build a complete open source robotic development environment together.

  • Unix philosophy– Set of cultural norms for developing software
  • (Agile Development) – Manifesto for Agile Software Development
  • Gitflow– Makes parallel development very easy, by isolating new development from finished work
  • (Taiga) – Agile Projectmanagment Tool
  • (Kanboard) – Minimalistic Kanban Board
  • (Gitlab) – Simple Selfhosted Gitlab Server with Docker
  • (Gogs) – Aims to build a simple, stable and extensible self-hosted Git service that can be setup in the most painless way
  • Woost– Workflow Automation, Collaboration with Externals
  • Wekan– Meteor based Kanban Board

– Python Library for REST API of Jira)

  • Taiga API– Python Library for REST API of Taiga
  • Chronos-Timetracker– Desktop client for JIRA. Track time, upload worklogs without a hassle
  • Grge– Grge is a daemon and command line utility augmenting GitLab
  • gitlab-triage– GitLab’s issues and merge requests triage, automated!
  • Helpy– is a modern, open source helpdesk customer support application
  • Documentation and Presentation

    • Typora– A Minimalist Markdown Editor
    • Markor– A Simple Markdown Editor for your Android Device
    • Pandoc– Universal markup converter
    • Yaspeller– Command line tool for spell checking
    • Doxygen– Doxygen is the de facto standard tool for generating documentation from annotated C sources
    • (Word-to-Markdown- A ruby ​​gem to liberate content from Microsoft Word document)
    • DeepL– DeepL, an online translator that outperforms Google, Microsoft and Facebook
    • carbon– Share beautiful images of your source code
    • ASCIIMATICS– Create a GIF for your command line examples
    • inkscape– Inkscape is a professional vector graphics editor for Linux, Windows and macOS
    • Reveal-Hugo– A Hugo theme for Reveal.js that makes authoring and customization a breeze. With it, you can turn any properly-formatted Hugo content into a HTML presentation.
    • Hugo-Webslides– This is a Hugo template to create WebSlides presentation using markdown.
    • jupyter2slides– Cloud Native Presentation Slides with Jupyter Notebook Reveal.js
    • (patat) ****************** – Terminal-based presentations using Pandoc
    • github-changelog-generator– Automatically generate change log from your tags, issues, labels and pull requests on GitHub.
    • GitLab-Release-Note-Generator– A Gitlab release note generator that generates release note on latest tag

    Architecture and Design

    • YED– yEd is a powerful desktop application that can be used to quickly and effectively generate high-quality diagrams
    • yed_py– Generates graphML that can be opened in yEd
    • Plantuml– Web application to generate UML diagrams on-the-fly in your live documentation
    • rqt_graph– rqt_graph provides a GUI plugin for visualizing the ROS computation graph
    • rqt_launchtree– An RQT plugin for hierarchical launchfile configuration introspection.
    • cpp-dependencies– Tool to check C #include dependencies (dependency graphs created in .dot format)
    • pydeps– Python Module Dependency graphs
    • Aztarna– a footprinting tool for robots.

    Development Environment

    • ROS– Template for ROS node standardization in C
    • Launch– Templates on how to create launch files for larger projects
    • (Bash) – A bash scripting template incorporating best practices & several useful functions
    • (URDF) – Examples on how to create Unified Robot Description Format (URDF) for different kinds of robots
    • Python– Style guide to be followed in writing Python code for ROS
    • Docker– The Dockerfile in the minimal-ade project shows a minimal example of how to create a custom base image

    Code and Run

    • (Vim-ros

    – Vim plugin for ROS development

  • Visual Studio Code– Code editor for edit-build-debug cycle.
  • atom– Hackable text editor for the 21 st century
  • Sublime– A sophisticated text editor for code, markup and prose
  • ade-cli– The ADE Development Environment (ADE) uses docker and Gitlab to manage environments of per project development tools and optional volume images
  • Jupyter ROS– Jupyter widget helpers for ROS, the Robot Operating System
  • ros_rqt_plugin– The ROS Qt Creator Plug-in
  • ROS IDEs– This page collects experience and advice on using integrated development environments (IDEs) with ROS.)
  • TabNine– The all-language autocompleter
  • kite– Use machine learning to give you useful code completions for Python
  • jedi– Autocompletion and static analysis library for python
  • roslibpy– Python ROS Bridge library allows to use Python and IronPython to interact with ROS, the open-source robotic middleware.
  • Pybind 11– Seamless operability between C 11 and Python
  • Build and Deploy

    • Bloom– A release automation tool which makes releasing catkin packages easier
    • catkin_tools– Command line tools for working with catkin
    • industrial_ci– Easy continuous integration repository for ROS repositories
    • gitlab-runner– runs tests and sends the results to GitLab
    • colcon-core– command line tool to improve the workflow of building, testing and using multiple software packages
    • gitlab-release– Simple python3 script to upload files (from ci) to the current projects release (tag)
    • clang– This is a compiler front- end for the C family of languages (C, C , Objective-C, and Objective-C ) which is built as part of the LLVM compiler infrastructure project

    Lint and Format

    • (cppcheck) – Static analysis of C / C code
    • shellcheck– a static analysis tool for shell scripts
    • catkin_lint– catkin_lint checks package configurations for the catkin build system of ROS.
    • pylint– Pylint is a Python static code analysis tool which looks for programming errors, helps enforcing a coding standard, sniffs for code smells and offers simple refactoring suggestions.
    • black– The uncompromising Python code formatter
    • pydocstyle– pydocstyle is a static analysis tool for checking compliance with Python docstring conventions

    Version Control

    • meld– Meld is a visual diff and merge tool that helps you compare files, directories, and version controlled projects
    • tig– Text-mode interface for git
    • gitg– is a graphical user interface for git
    • (git-cola) – The highly caffeinated Git GUI
    • Python-gitlab– is a Python package providing access to the GitLab server API.
    • (bfg-repo-cleaner) – Removes large or troublesome blobs like git-filter-branch does, but faster.
    • nbdime– Tools for diffing and merging of Jupyter notebooks.
    • (semantic-release) – Fully automated version management and package publishing
    • (Git-repo) – Git-Repo helps manage many Git repositories, does the uploads to revision control systems, and automates parts of the development workflow


    • (HRIM

    – An information model for robot hardware

  • (URDF) – Repository for Unified Robot Description Format (URDF) parsing code
  • urdf- viz– Visualize URDF / XACRO file, URDF Viewer works on Windows / MacOS / Linux
  • solidworks_urdf_exporter– SolidWorks to URDF Exporter
  • FreeCAD– Your own 3D parametric modeler
  • Calibration

    • lidar_align– A simple method for finding the extrinsic calibration between a 3D lidar and a 6-dof pose sensor
    • kalibr– The Kalibr visual-inertial calibration toolbox
    • Calibnet– Self-Supervised Extrinsic Calibration using 3D Spatial Transformer Networks
    • lidar_camera_calibration– ROS package to find a rigid-body transformation between a LiDAR and a camera
    • ILCC– Reflectance Intensity Assisted Automatic and Accurate Extrinsic Calibration of 3D LiDAR
    • easy_handeye– Simple, straighforward ROS library for hand-eye calibration
    • imu_utils– A ROS package tool to analyze the IMU performance
    • kalibr_allan– IMU Allan standard deviation charts for use with Kalibr and inertial kalman filters


    • Webots– Webots is an open source robot simulator compatible (among others) withROSand (ROS2) ******************.
    • lgsv– LG Electronics America R&D Center has developed an HDRP Unity-based multi- robot simulator for autonomous vehicle developers.
    • carla– Open-source simulator for autonomous driving research
    • deepdive– End-to-end simulation for self-driving cars
    • uuv_simulator– Gazebo / ROS packages for underwater robotics simulation
    • AirSim– Open source simulator for autonomous vehicles built on Unreal Engine
    • self-driving-car-sim– A self- driving car simulator built with Unity
    • (ROSIntegration

    – Unreal Engine Plugin to enable ROS Support)

  • gym-gazebo– An OpenAI gym extension for using Gazebo known as gym-gazebo
  • highway-env– A collection of environments for autonomous driving and tactical decision-making tasks
  • VREP Interface– ROS Bridge for the VREP simulator
  • Pipeline

    • (SARosPerceptionKitti) – ROS package for the Perception (Sensor Processing, Detection, Tracking and Evaluation) of the KITTI Vision Benchmark Suite
    • multiple-object-tracking-lidar– C implementation to Detect, track and classify multiple objects using LIDAR scans or point cloud

    Machine Learning

    • (DLIB

    – A toolkit for making real world machine learning and data analysis applications in C )

  • Fastai– The fastai library simplifies training fast and accurate neural nets using modern best practices.
  • tpot– A Python Automated Machine Learning tool that optimizes machine learning pipelines using genetic programming
  • deap– Distributed Evolutionary Algorithms in Python
  • Gym– A toolkit for developing and comparing reinforcement learning algorithms.
  • tensorflow_ros_cpp– A ROS package that allows to do Tensorflow inference in C without the need to compile TF yourself.
  • cadrl_ros– ROS package for dynamic obstacle avoidance for ground robots trained with deep RL
  • Image Processing

    • vision_visp– Wraps the ViSP moving edge tracker provided by the ViSP visual servoing library into a ROS package
    • deep_object_pose– Deep Object Pose Estimation
    • DetectAndTrack– Detect-and-Track: Efficient Pose
    • (SfMLearner) – An unsupervised learning framework for depth and ego-motion estimation
    • (imgaug) – Image augmentation for machine learning experiments
    • (vision_opencv) – Packages for interfacing ROS with OpenCV, a library of programming functions for real time computer vision.
    • (darknet_ros) – YOLO ROS: Real-Time Object Detection for ROS
    • TF -pose-estimation– Deep Pose Estimation implemented using Tensorflow with Custom Architectures for fast inference.
    • find-object– Simple Qt interface to try OpenCV implementations of SIFT, SURF, FAST, BRIEF and other feature detectors and descriptors
    • (yolact

    – A simple, fully convolutional model for real-time instance segmentation.

    Point Cloud Processing

    • cilantro– A lean C library for working with point cloud data
    • open3d– Open3D: A Modern Library for 3D Data Processing
    • SqueezeSeg– Implementation of SqueezeSeg, convolutional neural networks for LiDAR point clout segmentation
    • point_cloud_io– ROS nodes to read and write point clouds from and to files (eg ply, vtk).
    • python-pcl– Python bindings to the pointcloud library
    • libpointmatcher– An “Iterative Closest Point” library for 2-D / 3-D mapping in Robotics
    • depth_clustering– Fast and robust clustering of point clouds generated with a Velodyne sensor.
    • lidar-bonnetal– Semantic and Instance Segmentation of LiDAR point clouds for autonomous driving
    • CSF– LiDAR point cloud ground filtering / segmentation (bare earth extraction) method based on cloth simulation
    • robot_body_filter– A highly configurable LaserScan / PointCloud2 filter that allows to dynamically remove the 3D body of the robot from the measurements.
    • grid_map– Universal grid map library for mobile robotic mapping
    • elevation_mapping– Robot-centric elevation mapping for rough terrain navigation


    • EVO– Python package for the evaluation of odometry and SLAM
    • robot_localization– is a package of nonlinear state estimation nodes
    • fuse– General architecture for performing sensor fusion live on a robot.
    • (rep -) – Naming conventions and semantic meaning for coordinate frames of mobile platforms used with ROS.
    • (GeographicLib) ****************** – A C library for geographic projections.
    • (ntripbrowser- A Python API for browsing NTRIP) Networked Transport of RTCM via Internet Protocol.
    • imu_tools– IMU-related filters and visualizers .
    • RTKLIB– A version of RTKLIB optimized for single and dual frequency low cost GPS receivers, especially u-blox receivers


    • loam_velodyne– Laser Odometry and Mapping (Loam) is a realtime method for state estimation and mapping using a 3D lidar.
    • lio-mapping– Implementation of Tightly Coupled 3D Lidar Inertial Odometry and Mapping (LIO-mapping)
    • A-LOAM– Advanced implementation of LOAM
    • cartographer_ros– Provides ROS integration for Cartographer
    • loam_livox– A robust LiDAR Odometry and Mapping (LOAM) package for Livox-LiDAR
    • StaticMapping– Use LiDAR to map the static world

    • dso– Direct Sparse Odometry
    • Viso2– A ROS wrapper for libviso2, a library for visual odometry
    • xivo– X Inertial-aided Visual Odometry
    • Rovio– Robust Visual Inertial Odometry Framework
    • (MIT Kimera-Semantics) – C library for real-time metric-semantic visual-inertial Simultaneous Localization And Mapping (SLAM)
    • (LSD-SLAM) – LSD-SLAM: Large-Scale Direct Monocular SLAM is a real-time monocular SLAM
    • (CubeSLAM and ORB SLAM) – Monocular 3D Object Detection and SLAM Package of CubeSLAM and ORB SLAM

    • MapsModelsImporter– A Blender add-on to import models from google maps
    • (Lanelet2) – Map handling framework for automated driving
    • (barefoot) – Online and Offline map matching that can be used stand-alone and in the cloud
    • (iD) – The easy-to-use OpenStreetMap editor in JavaScript
    • (segmap) – A map representation based on 3D segments
    • (Mapbox) – is a JavaScript library for interactive, customizable vector maps on the web
    • OSRM -backend– Open Source Routing Machine – C backend

    Behavior and Decision

    • BehaviorTree.CPP– Behavior Trees Library in C
    • RAFCON– Uses hierarchical state machines, featuring concurrent state execution, to represent robot programs

    Planning and Control

    • rrt– C RRT (Rapidly-exploring Random Tree) implementation
    • HypridAStarTrailer– A path planning algorithm based on Hybrid A * for trailer truck.
    • path_planner– Hybrid A * Path Planner for the KTH Research Concept Vehicle
    • open_street_map– ROS packages for working with Open Street Map geographic information.
    • Open Source Car Control– is an assemblage of software and hardware designs that enable computer control of modern cars in order to facilitate the development of autonomous vehicle technology
    • fastrack– A ROS implementation of Fast and Safe Tracking (FaSTrack).

    Data Interaction

    • dynamic_reconfigure– The focus of dynamic_reconfigure is on providing a standard way to expose a subset of a node’s parameters to external reconfiguration
    • mir– Mir is set of libraries for building Wayland based shells
    • qtpy– Provides an uniform layer to support PyQt5, PySide2, PyQt4 and PySide with a single codebase
    • rqt– rqt is a Qt-based framework for GUI development for ROS. It consists of three parts / metapackages
    • cage– This is Cage, a Wayland kiosk. A kiosk runs a single, maximized application.
    • chilipie– Easy-to-use Raspberry Pi image for booting directly into full-screen Chrome

    Command Line

    – A code-searching tool similar to ack, but faster.

  • fzf– A command-line fuzzy finder
  • pkgtop– Interactive package manager and resource monitor designed for the GNU / Linux.
  • gocui– Minimalist Go package aimed at creating Console User Interfaces.
  • TerminalImageViewer– Small C program to display images in a (modern) terminal using RGB ANSI codes and unicode block graphics characters
  • rosshow– Visualize ROS topics inside a terminal with Unicode / ASCII art
  • python-prompt-toolkit– Library for building powerful interactive command line applications in Python
  • bash-script -template– A best practices Bash script template with several useful functions
  • Guake– Drop-down terminal for GNOME
  • Wemux– Multi-User Tmux Made Easy
  • TMUXP– tmux session manager built on libtmux
  • Mapscii– World map renderer for your console
  • Terminator– The goal of this project is to produce a useful tool for arranging terminals
  • bat– A cat (1) clone with wings.
  • Storage and Record

    • ncdu– Ncdu is a disk usage analyzer with an ncurses interface
    • borg– Deduplicating archiver with compression and authenticated encryption
    • bag-database– A server that catalogs bag files and provides a web-based UI for accessing them
    • marv-robotics– MARV Robotics is a powerful and extensible data management platform
    • kitti2bag– Convert KITTI dataset to ROS bag file the easy way!
    • rosbag_editor– Create a rosbag from a given one, using a simple GUI
    • Nextcloud– Nextcloud is a suite of client-server software for creating and using file hosting services.
    • ros_type_introspection– Deserialize ROS messages that are unknown at compilation time

    Network Distributed File Systems

    • sshfs– File system based on the SSH File Transfer Protocol
    • (moosefs) – a scalable distributed storage system
    • (ceph) – is a distributed object, block, and file storage platform
    • (NFS) – is a distributed file system protocol originally developed by Sun Microsystems (Sun) in 1984, allowing a user on a client computer to access files over a computer network much like local storage is accessed

    High Performance Computing

    • nvidia-docker– Build and run Docker containers leveraging NVIDIA GPUs
    • kubernetes– Production-Grade Container Scheduling and Management
    • kubeflow– Machine Learning Toolkit for Kubernetes
    • log-pilot– Collect logs for docker containers
    • traefik– The Cloud Native Edge Router
    • graylog2-server– Free and open source log management
    • ansible– Ansible is a radically simple IT automation platform that makes your applications and systems easier to deplo
    • docker-py– A Python library for the Docker Engine API
    • noVNC– VNC client using HTML5
    • Slurm– Slurm: A Highly Scalable Workload Manager
    • jupyterhub– Multi-user server for Jupyter notebooks
    • Portainer– Making Docker management easy

    • rviz_cloud_annotation– Point cloud annotation tool based on RViz
    • PixelAnnotationTool– Annotate quickly images
    • (LabelImg) – LabelImg is a graphical image annotation tool and label object bounding boxes in images


    • Webviz– web-based visualization libraries like rviz
    •– An open-source, interactive graphing library for Python
    • PlotJuggler– The timeseries visualization tool that you deserve
    • bokeh– Interactive Data Visualization in the browser, from Python
    • voila– From Jupyter notebooks to standalone web applications and dashboards
    • Pangolin– Pangolin is a lightweight portable rapid development library for managing OpenGL display / interaction and abstracting video input.
    • rqt_bag– provides a GUI plugin for displaying and replaying ROS bag files.

    – WebGL point cloud viewer for large datasets

  • point_cloud_viewer– makes viewing massive point clouds easy and convenient
  • ParaView– VTK -based Data Analysis and Visualization Application
  • RViz

    • MAPVIZ– Modular ROS visualization tool for 2D data.
    • rviz_cinematographer– Easy to use tools to create and edit trajectories for the rviz camera.
    • rviz_satellite– Display internet satellite imagery in RViz
    • rviz_visual_tools– C API wrapper for displaying shapes and meshes in Rviz
    • tf_keyboard_cal– Allows manual control of a TF through the keyboard or interactive markers

    • htop– htop is an interactive text-mode process viewer for Unix systems. It aims to be a better ‘top’.
    • ATOP– System and process monitor for Linux with logging and replay function
    • psutil– Cross-platform lib for process and system monitoring in Python
    • gputil– A Python module for getting the GPU status from NVIDA GPUs using nvidia-smi programmically in Python
    • gpustat– A simple command-line utility for querying and monitoring GPU status
    • nvtop– NVIDIA GPUs htop like monitoring tool
    • (spdlog) – Very fast, header-only / compiled, C logging library

    Operation System

    • Yocto– Produce tools and processes that enable the creation of Linux distributions for embedded software that are independent of the underlying architecture of the embedded hardware
    • (Automotive Graded Linux) – is a collaborative open source project that is bringing together automakers, suppliers and technology companies to build a Linux-based, open software platform for automotive applications that can serve as the de facto industry standard
    • (robot_upstart) – presents a suite of scripts to assist with launching background ROS processes on Ubuntu Linux PCs
    • (bitbake) – is a generic task execution engine that allows shell and Python tasks to be run efficiently and in parallel while working within complex inter-task dependency constraints.
    • (Jailhouse) – Jailhouse is a partitioning Hypervisor based on Linux
    • (Xen) – is an open-source (GPL) type-1 or baremetal hypervisor
    • QEMU– is a generic and open source machine emulator and virtualizer
    • rosserial– A ROS client library for small, embedded devices, such as Arduino
    • (meta-ros

    – OpenEmbedded Layer for ROS Applications

  • meta-balena– Run Docker containers on embedded devices
  • Network and Middleware

    • pyshark– Python wrapper for tshark, allowing python packet parsing using wireshark dissectors
    • pingtop– Ping multiple servers and show results in a top-like terminal UI
    • termshark– A terminal UI for tshark, inspired by Wireshark
    • nethogs– It groups bandwidth by process
    • canmmatrix– Converting CAN Database Formats .arxml .dbc .dbf .kcd
    • performance_test– Tool to test the performance of pub / sub based communication frameworks.
    • tcpreplay– Pcap editing and replay tools
    • iperf– A TCP, UDP, and SCTP network bandwidth measurement tool
    • can-utils– Linux-CAN / SocketCAN user space applications
    • ros_canopen– CANopen driver framework for ROS
    • decanstructor– The definitive ROS CAN analysis tool.
    • ros1_bridge– ROS 2 package that provides bidirectional communication between ROS 1 and ROS 2
    • Fast-RTPS– protocol, which provides publisher-subscriber communications over unreliable transports such as UDP, as defined and maintained by the Object Management Group (OMG) consortium
    • ptpd– PTP daemon (PTPd) is an implementation the Precision Time Protocol (PTP) version 2 as defined by ‘IEEE Std 1588 – 2008 ‘. PTP provides precise time coordination of Ethernet LAN connected computers
    • (wireless) – Making info about wireless networks available to ROS.
    • protobuf– Google’s data interchange format

    Debugging and Tracing

    • lptrace– It lets you see in real-time what functions a Python program is running
    • pyre-check– Performant type-checking for python
    • FlameGraph– Visualize profiled code
    • (gpuvis) ****************** – GPU Trace Visualizer
    • sanitizer– AddressSanitizer, ThreadSanitizer , MemorySanitizer
    • cppinsights– C Insights – See your source code with the eyes of a compiler
    • inspect– The inspect module provides functions for learning about live objects, including modules, classes, instances, functions, and methods
    • Roslaunch Nodes in Valgrind or GDB– When debugging roscpp nodes that you are launching with roslaunch, you may wish to launch the node in a debugging program like gdb or valgrind instead.

    • gocryptfs– Encrypted overlay filesystem written in Go
    • How-to-Secure-A-Linux-Server– An evolving how-to guide for securing a Linux server.
    • lynis– Lynis – Security auditing tool for Linux, macOS, and UNIX-based systems. Assists with compliance testing (HIPAA / ISO 27001 / PCI DSS) and system hardening
    • WireGuard– WireGuard is a novel VPN that runs inside the Linux Kernel and utilizes state-of-the-art cryptography
    • ssh-auditor– Scans for weak ssh passwords on your network
    • vulscan– Advanced vulnerability scanning with Nmap NSE
    • nmap-vulners– NSE script based on API
    • Brutespray– Automatically attempts default creds on found services.
    • fail2ban– Daemon to ban hosts that cause multiple authentication errors
    • is-website-vulnerable– Finds publicly known security vulnerabilities in a website’s frontend JavaScript libraries
    • (DependencyCheck) – is a software composition analysis utility that detects publicly disclosed vulnerabilities in application dependencies
    • firejail– Firejail is a SUID sandbox program that reduces the risk of security breaches by restricting the running environment of untrusted applications using Linux namespaces, seccomp-bpf and Linux capabilities
    • (RVD) – Robot Vulnerability Database. Community-contributed archive of robot vulnerabilities and weaknesses


    • open-autonomous-safety– OAS is a fully open-source library of Voyage’s safety processes and testing procedures, designed to supplement existing safety programs at self-driving car startups across the world.
    • CarND-Functional- Safety-Project– create functional safety documents Udacity project
    • Automotive Grade Linux– Automotive Grade Linux is a collaborative open source project that is bringing together automakers, suppliers and technology companies to accelerate the development and adoption of a fully open software stack for the connected car
    • (safe_numerics) – Replacements to standard numeric types which throw exceptions on errors


    • Realtime Testing Best Practices– This page is intended to serve as a collecting point for presentations, documents, results, links and descriptions about testing Realtime performance of Linux systems.
    • ELISA– Project is to make it easier for companies to build and certify Linux-based safety-critical applications – systems whose failure could result in loss of human life, significant property damage or environmental damage
    • PREEMPT_RT kernel patch– Aim of the PREEMPT_RT kernel patch is to minimize the amount of kernel code that is non-preemptible.


    • awesome-safety-critical– List of resources about programming practices for writing safety-critical software.
    • awesome-ros2– A curated list of awesome Robot Operating System Version 2.0 (ROS 2) resources and libraries.