Open-source alternatives to Mujoco

Pinocchio is a multi-body dynamics engine and rigid body physics library designed for computing forward and inverse kinematics and dynamics for articulated rigid-body systems. It functions as a robot kinematics solver and model parser, enabling the analysis of complex robotic systems through kinematic and dynamic computations. The project distinguishes itself with specialized capabilities for constrained dynamics, including the calculation of contact impulses and centroidal momentum. It provides a parallel processing collision detection system for computing minimal distances between rigid bod

AirSim is a high-fidelity simulation platform designed for the development and testing of autonomous vehicles. Built as a plugin for game engines, it provides a physics-based environment that models vehicle dynamics and sensor data, serving as a foundation for robotics research, computer vision training, and reinforcement learning. The platform distinguishes itself through its support for hardware-in-the-loop and software-in-the-loop testing, allowing developers to validate control logic and firmware against real-world signals or concurrent processes. It offers extensive programmatic control

Matter-js is a 2D rigid body physics engine written in JavaScript for simulating realistic physical interactions, collisions, and dynamics in web browsers. It functions as a web physics simulation library that calculates motion, gravity, and constraints for objects rendered on a web canvas. The library includes a built-in canvas physics visualizer to draw physical bodies, joints, and constraints for debugging and gameplay. It distinguishes itself through a plugin system that supports recursive dependency resolution and internal method patching to inject custom logic into the engine's executio

Genesis World is an embodied AI simulation platform designed for training robotic agents through physics-based interactions. It centers on a multi-physics simulation engine that integrates rigid body, particle, and finite element method dynamics, supported by a parallel simulation kernel compiler that translates Python functions into optimized GPU and CPU kernels. The platform features a photorealistic robot renderer that utilizes path-tracing and Gaussian Splatting to generate synthetic training data. It includes a domain randomization framework to vary lighting and physical parameters acros

Webots is a physics-based robot simulator and development environment used for modeling, programming, and testing the behavior of robots in a simulated 3D physical world. It serves as a virtual prototyping tool to verify mechanical and electronic systems through the creation of virtual robot models and control logic. The platform enables a full robotics simulation workflow, including the development of robot controllers and the programming of autonomous agent behaviors. It focuses on physical system modeling to represent the mechanical properties of hardware and simulate real-world interactio

dm_control is a physics-based simulation framework and robot control simulation toolkit designed for creating and interacting with continuous control tasks. It serves as a suite of reinforcement learning environments and a benchmarking tool for evaluating autonomous agents within virtual physics spaces. The framework provides a collection of environments based on MuJoCo physics bindings to simulate rigid body dynamics and contact forces. It features hardware-accelerated rendering and interactive viewers for the visualization of physics environments and agent behavior. The system supports the

jetson-inference is a set of libraries and tools for executing optimized deep learning models on embedded GPU hardware. Its primary purpose is to enable real-time computer vision and AI inference at the edge with low latency and high throughput. The project distinguishes itself through high-performance streaming analytics and the ability to execute concurrent AI pipelines on auto-grade silicon. It provides specialized support for multi-sensor stream processing, utilizing zero-copy data transport to load camera frames directly into GPU memory. The codebase covers a broad surface of capabiliti

This project is an open-source 3D game engine designed for building high-fidelity games, simulations, and cinematic environments. It functions as a robotics simulation platform with native integration for ROS 2 to model robot controllers and sensors. The engine features a multi-threaded Forward+ physically based renderer that supports hardware-accelerated ray tracing and global illumination. The system is built on a modular extension architecture using Gems to add or replace features without modifying core binaries. It includes a native SDK for AWS cloud integration, enabling IAM authenticati

FlappySwift is a side-scrolling arcade game implementation built for Apple platforms. Developed using the Swift programming language, this 2D game project features a physics-based environment where a player controls a character to avoid obstacles. The project utilizes the SpriteKit framework to handle rigid body dynamics, gravitational forces, and sprite-based rendering. Game flow is managed through a state machine that controls transitions between the start menu, active gameplay, and game over screens. The implementation covers 2D physics simulation, including bounding-box collision detecti

JoltPhysics is a high-performance C++ physics engine designed for multi-threaded simulation of 3D rigid bodies and soft bodies. It serves as a deterministic simulation framework, ensuring identical results across different platforms and architectures to support networked synchronization. The engine distinguishes itself through a focus on concurrent execution across multiple CPU cores to handle large numbers of active bodies. It provides specialized systems for vehicle physics, including wheeled and tracked models, as well as soft body physics for deformable objects and cloth. The simulation

This project is a multi-purpose web platform serving as a canvas 2D game engine, a frontend engineering blog, and a markdown static site generator. It functions as a web graphics showcase and a technical knowledge base for sharing architectural decisions and performance optimizations. The platform implements a high-performance graphics framework using low-level drawing APIs, integrating skeletal animation and web physics for collision detection and realistic motion of two-dimensional objects. It simultaneously operates as a system for converting markdown source files into pre-rendered HTML pa

planck.js is a 2D rigid body physics engine for JavaScript and HTML5, based on Box2D. It provides a framework for simulating physical interactions and calculating the motion of solid objects within a two-dimensional virtual environment. The engine is designed for cross-platform web gaming, enabling the implementation of rigid body dynamics across different web browsers and devices. The library manages simulation through a constraint-based physics solver and rigid body state management. It utilizes iterative impulse resolution, semi-implicit Euler integration, and dynamic AABB tree partitioni

Gobot is a robotics framework for the Go programming language designed for developing robotics, drones, and IoT applications. It provides a hardware abstraction layer with standardized drivers to interact with GPIO, I2C, SPI, and PWM interfaces across various single-board computers and microcontrollers. The framework functions as an IoT device orchestrator and BLE device manager, enabling the coordination of multiple sensors, actuators, and Bluetooth Low Energy peripherals. It includes specialized interfaces for drone control, allowing for the management of flight maneuvers and video streams

Dummy-Robot is a software platform designed for the real-time teleoperation of desktop robotic arms. It functions as a human-robot interaction interface, translating gestural input and sensor data into fluid mechanical motion to enable remote physical task execution. The system utilizes a specialized control framework to map human hand movements directly to robotic actuators. By integrating sensor fusion and kinematic mapping, the software maintains low-latency synchronization between an operator's spatial inputs and the physical assembly, allowing for precise manipulation through a dedicated

Cocos2d-x is a high-performance C++ game development framework designed for building and deploying interactive applications across mobile, desktop, and web platforms. It functions as a cross-platform game engine that utilizes an entity-component system to manage object lifecycles, behaviors, and spatial relationships within a unified codebase. The engine is distinguished by its specialized 2D graphics rendering pipeline, which is optimized for hardware-accelerated performance when displaying sprites, particle effects, and skeletal animations. It provides developers with low-level access to gr

ElectronBot is a robotic system comprising custom PCB designs, an embedded circular display driver, an I2C servo controller, and a communication bridge. It integrates hardware schematics and layouts for control boards and sensor arrays with firmware designed to render images and animations on integrated circular screens. The system features a control bridge that links the physical robot hardware to the Unity game engine for real-time visualization and high-level control. Data exchange between the host computer and the embedded hardware is handled via a custom USB CDC serial communication prot

OpenMower is an autonomous lawn mower controller and firmware system that uses high-precision RTK GPS to navigate robotic mowers without the need for physical boundary wires. It functions as a GPS-based path planner and hardware management system that converts manual machines into autonomous units. The project includes a remote management application for monitoring and controlling mowers via a web or mobile interface. It integrates an obstacle avoidance system and safety layers that execute emergency stops when the device is lifted or crashes. The system manages robotic hardware through firm

The Open-Source Rover Platform is a hardware and software framework for building and controlling six-wheel planetary exploration rovers. It provides a six-wheel robot chassis and a modular robotics framework designed for integrating various motors, wheel sizes, and chassis materials. The platform features a six-wheel chassis equipped with a differential pivot suspension and an Ackerman steering mechanism to enable navigation across rugged outdoor terrain. Control is managed through a communication system that connects central processors to hardware via Bluetooth, WiFi, or USB for remote opera

Navigation2 is a navigation stack for ROS 2 designed for autonomous robot navigation. It provides a framework for computing optimal paths from a starting position to a goal while avoiding static and dynamic obstacles. The system utilizes a behavior tree orchestrator to coordinate complex navigation tasks and trigger recovery actions. Its architecture is plugin-based, allowing planners, controllers, and costmap layers to be swapped at runtime without recompiling the core system. The project covers path planning, motion control, and environmental mapping. It generates occupancy grids and costm

Cylon is a JavaScript robotics framework and hardware abstraction layer designed for controlling robots, drones, and IoT devices. It functions as an IoT device orchestrator that translates high-level JavaScript commands into hardware signals and manages multiple sensors and components concurrently. The system utilizes a modular architecture of drivers and adaptors to normalize diverse hardware signals into a unified programming interface. It enables the deployment of hardware control logic across various environments, including web browsers and mobile applications, through cross-platform bund

OM1 is a multimodal AI agent runtime and orchestration framework designed to connect large language models to physical robot hardware and sensors. It provides an execution environment that processes audio, video, and sensor data to drive autonomous decisions and actions in real-world settings. The system integrates a robotics SLAM and navigation stack with a hardware abstraction layer, allowing high-level AI commands to be translated into low-level motor and actuator instructions. It distinguishes itself by incorporating blockchain-based governance to enforce immutable operational rules and p

Valetudo is a custom firmware project for robot vacuums that enables local-only control, removing dependencies on cloud servers and protecting user privacy. It replaces proprietary vendor binaries with open source software to ensure that data, including floor plans and images, is not uploaded to external clouds. The project distinguishes itself by providing a rooted firmware installation process that prevents forced vendor updates. It implements a standardized control interface across different hardware brands and utilizes an MQTT-based message bus to facilitate integration with open source a

This project provides a complete set of design files and hardware specifications for a 3D-printable industrial-style robot arm. The system includes a CAN bus robot controller for managing stepper motors and sensors, a kinematics engine for calculating joint angles and poses, and a UDP-based Python API for sending motion commands and monitoring telemetry. The system features a force-controlled robotic gripper that utilizes field-oriented control on stepper motors to enable compliant grasping and precise force sensing. It also includes a 3D position visualization tool for real-time telemetry tr

Johnny-Five is a JavaScript robotics framework and microcontroller hardware interface designed for programming robots and IoT devices. It provides a standardized library for managing pins, motors, and displays across various microcontroller platforms, allowing developers to control sensors and actuators using a consistent JavaScript API. The framework is distinguished by its use of a plugin-based hardware abstraction system, which enables communication with diverse hardware platforms and protocols. It supports real-time hardware manipulation and debugging through a read-eval-print loop that a

This project is a comprehensive research platform designed for the end-to-end lifecycle of robotic learning. It provides a modular framework for training neural network policies—specifically through imitation and reinforcement learning—and deploying them onto physical robotic hardware. By offering a unified interface for hardware abstraction, the platform decouples high-level control logic from the specific sensors and actuators of diverse robotic systems. The framework distinguishes itself through a standardized approach to data and policy management. It utilizes a consistent schema for reco

PythonRobotics is a comprehensive collection of modular robotics algorithms and educational simulations designed for autonomous navigation, state estimation, and motion control. The project provides a library of standalone implementations for path planning, localization, mapping, and kinematics, serving as a resource for researchers and students to experiment with foundational and advanced robotic theories. The project distinguishes itself through an algorithm-centric design where each module functions as an isolated script, allowing for independent testing and clear pedagogical demonstration

This project is a comprehensive educational resource and knowledge base designed to guide developers through the technical requirements of a career in game programming. It functions as a structured curriculum that organizes essential engineering principles and mathematical foundations into a logical roadmap, facilitating a clear progression from foundational concepts to advanced system mastery. The repository serves as a centralized hub for navigating the multidisciplinary domains of interactive software development. It provides curated references and learning materials across core areas incl