CoppeliaSim
CoppeliaSim is a versatile and scalable robot simulation platform developed by Coppelia Robotics AG, enabling the creation, composition, and simulation of any robot or complex system through an integrated development environment based on a distributed control architecture.[1] Formerly known as the Virtual Robot Experimentation Platform (V-REP), it originated as a general-purpose framework introduced in 2013 to facilitate portable and flexible simulation for incorporating various control techniques in robotics research and development.[2] The software supports five physics engines—Bullet, ODE, Vortex, Newton, and MuJoCo—for accurate dynamic simulations, along with forward and inverse kinematics solvers, sensor modeling (including proximity and vision sensors), and path planning via the Open Motion Planning Library (OMPL).[1] It provides extensive application programming interfaces (APIs) in seven languages, including Lua, Python, C/C++, Java, MATLAB, Octave, and Rust, allowing seamless integration with external tools and real-time control of hardware.[1] CoppeliaSim is widely applied in fast algorithm prototyping, factory automation simulations, verification of digital twins, robotics education, and remote monitoring of physical systems, with features like multilevel undo/redo, collision detection, and a browser-based 3D viewer enhancing its usability.[1] The platform is cross-platform, running on Windows, Linux, and macOS, and is available in dual-licensed editions: a commercial "Pro" version for full editing and industrial use, and an "Edu" version restricted to educational purposes.[1] As of May 2025, the latest stable release is version 4.10.0.[3] Its modular design, supported by plugins and add-ons, makes it suitable for multi-robot systems, kinematic design, and interdisciplinary applications in automation and control.[1]Overview
Development and maintenance
CoppeliaSim is developed and maintained by Coppelia Robotics AG, a company headquartered in Zurich, Switzerland.[1] This follows initial development efforts supported by Toshiba Corporate R&D Center.[4] Maintenance is led by the core development team at Coppelia Robotics AG, focusing on regular software updates, bug fixes, and feature enhancements to support evolving robotics applications and user needs.[3][5] The most recent stable release, version 4.10.0 (revision 0), was made available on May 14, 2025, including improvements such as bug resolutions, new MIDI I/O and events filtering plugins, and enhanced WebSockets functionality for client-server interactions.[3] CoppeliaSim provides cross-platform compatibility, running natively on Windows, Linux, and macOS operating systems.[6]Licensing and platforms
CoppeliaSim operates under a dual licensing model, with the core library available under the GNU General Public License (GPL) for open-source applications and separate commercial licenses for proprietary or closed-source use.[7][8] The educational version (Edu) is offered free for non-commercial purposes exclusively to students, teachers, professors, schools, and universities, providing full simulation and scene editing capabilities without warranty.[8] This version prohibits commercial applications and requires adherence to specific distribution rules for any shared plugins, such as retaining educational watermarks.[8] For commercial deployments, the professional version (Pro) requires a paid license, enabling proprietary integration, customer distribution, and access to dedicated support and customizations from Coppelia Robotics AG.[8] A Lite runtime variant is also available under commercial terms for embedding in end-user applications. CoppeliaSim is compatible with multiple platforms, including 64-bit Windows 10 and later, 64-bit Linux distributions such as Ubuntu 18.04/20.04/22.04/24.04 and Debian 10/11/12, and macOS 10.13 and later.[1] It depends on OpenGL 2.1 or higher for visualization and rendering, with performance varying based on graphics hardware.[9] No strict minimum hardware specifications are mandated, though a dedicated graphics card is recommended for complex simulations.[10]History
Origins and early development
The Virtual Robot Experimentation Platform (V-REP) originated as a project initiated around 2010 within the Corporate Research & Development Center of Toshiba Corporation in Japan, aimed at creating a versatile 3D robot simulator to support prototyping, algorithm development, and factory automation simulations.[4] Key early contributors included Fumio Ozaki and Nobuto Matsuhira from Toshiba, alongside Marc Freese from K-Team Corporation and Surya P. N. Singh, who collaborated on its modular and decentralized architecture to enable concurrent simulation of control, actuation, sensing, and monitoring in complex robotic scenarios.[11] This initial development emphasized a small-footprint design that balanced functionality with extensibility, distinguishing it from more centralized simulation approaches prevalent at the time.[12] V-REP was formally introduced to the robotics community in 2010 through a paper presented at the International Conference on Simulation, Modeling, and Programming for Autonomous Robots (SIMPAR), where it was described as a portable framework for rapid prototyping and system verification in robotics applications.[12] By 2013, the platform had evolved significantly, incorporating embedded scripting capabilities and support for multiple programming interfaces, such as Lua and remote APIs, to facilitate scalable control architectures.[13] This growth culminated in its presentation at the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), where Eric Rohmer, Surya P. N. Singh, and Marc Freese highlighted V-REP's versatility in handling diverse simulation tasks, including kinematics, dynamics, and vision-based sensing, through a distributed control model that allowed independent module operations.[13] Following its introduction, V-REP saw early adoption in both academic research for algorithm testing and industrial settings for robot system verification and safety monitoring, establishing it as a robust tool for addressing simulation needs in robotics by 2013.[13] Its open architecture enabled integration with emerging middleware like ROS, further accelerating its use in educational and prototyping environments.[13] In 2019, V-REP was rebranded as CoppeliaSim to reflect ongoing enhancements.[1]Rebranding and evolution
In late November 2019, the original developers discontinued further development of V-REP, the predecessor to CoppeliaSim, with the final V-REP release being version 3.6.2 in June of that year.[3] To ensure continued advancement, Coppelia Robotics AG forked the project and rebranded it as CoppeliaSim, starting with version 4.0.0 released on November 26, 2019, thereby preserving the simulator's core functionality while enabling ongoing enhancements.[3][1] CoppeliaSim maintains full backward compatibility with V-REP, allowing seamless use of existing scene files (.ttt, .ttm), models, and scripts without modifications, which supports a smooth transition for users and researchers reliant on prior workflows.[3] Post-rebranding, CoppeliaSim has seen evolutionary improvements focused on performance, physics capabilities, and API extensibility through version 4.10. Enhanced performance includes optimizations such as the upgrade to MuJoCo physics engine version 3.2.6 in release 4.9.0, which improved simulation speeds by factors of 2 to 10 times and accelerated scene rebuilding.[3] New physics integrations feature the addition of MuJoCo support in version 4.4.0, enabling advanced simulations like soft body dynamics, adhesion modeling, and novel integrators for more realistic interactions.[3] Expanded API support encompasses integrations like WebSockets in version 4.3.0 for real-time communication, ZeroMQ in version 4.2.0 for messaging, and the Eigen plugin in version 4.10.0 for efficient linear algebra operations, broadening compatibility with external tools and languages.[3]Core Features
Simulation and physics engines
CoppeliaSim provides versatile simulation capabilities for modeling robots, scenes, and environments, supporting both real-time and offline modes to accommodate various computational needs and hardware constraints. In real-time mode, the simulator aims to synchronize with the host computer's clock for interactive applications, while offline mode allows accelerated or decelerated execution for batch processing or analysis. This flexibility enables users to test dynamic behaviors in controlled virtual settings, ensuring accurate replication of physical interactions without hardware risks.[14][15] At the core of CoppeliaSim's dynamics simulation are five integrated physics engines, each selected for specific strengths in handling mechanical interactions. The Bullet physics library excels in 3D collision detection and supports both rigid and soft body dynamics, making it suitable for general-purpose simulations involving complex geometries.[15] The Open Dynamics Engine (ODE) focuses on open-source rigid body dynamics and efficient collision handling, ideal for straightforward multibody systems.[15] MuJoCo offers high-fidelity, precise dynamics modeling, including soft bodies, ropes, tendons, and advanced constraints defined via XML, which enhances realism in biologically inspired or deformable object scenarios.[15][16] Newton Dynamics provides a deterministic solver for consistent, reproducible results in real-time applications, minimizing variability across runs.[15] Vortex Studio delivers advanced multibody dynamics with realistic physical parameters, supporting high-accuracy simulations of vehicles and machinery, though it requires commercial licensing.[15] Users can switch engines dynamically within a scene to compare behaviors or optimize performance, with each engine configurable via a JSON editor for shape, joint, and global properties.[16] The platform adeptly manages complex setups, such as multi-robot interactions, object grasping, conveyor systems, and vehicle navigation over uneven terrain, by simulating realistic object responses and environmental influences like friction and gravity.[15][14] Integrated sensors, including proximity and vision types, interact seamlessly with the physics environment to detect and process dynamic events, enabling applications in perception-driven robotics.[14] Customization is extensive, allowing adjustments to simulation parameters like time steps for finer granularity, accuracy levels to balance computational load and precision, and engine-specific settings such as mass inertias or constraint forces to tailor simulations to particular use cases.[15][16]Kinematics and path planning
CoppeliaSim provides robust forward and inverse kinematics (IK) solvers tailored for manipulator and mobile robot control, enabling precise computation of joint configurations and end-effector poses within simulated environments. Forward kinematics calculates the position and orientation of an end effector from given joint values, accommodating complex mechanisms where direct computation may involve non-trivial transformations. Inverse kinematics, conversely, determines the joint values required to achieve a desired end-effector pose, leveraging Jacobian-based methods such as pseudoinverse, damped least squares, and null-space projections to handle singularities and redundancies effectively. These solvers operate through IK elements, which define kinematic chains with bases, links, tips, and targets, along with constraint specifications like position or orientation limits represented in Jacobian matrices.[17][18] IK groups in CoppeliaSim aggregate multiple elements, allowing sequential or simultaneous resolution of tasks with customizable properties like iteration counts and solver priorities, which is particularly useful for controlling serial manipulators or mobile platforms with interdependent joints. For mobile robots, such as differential drive systems, the solvers support wheel-ground constraints and non-holonomic motion models, facilitating accurate pose estimation and trajectory adjustment in planar or 3D spaces. The kinematics plugin ensures seamless integration with the simulation loop, where computed joint angles can drive dynamic models without disrupting real-time performance, thus validating kinematic chains against environmental interactions.[18][19] Path and motion planning in CoppeliaSim is facilitated by a plugin that wraps the Open Motion Planning Library (OMPL), offering flexible algorithms for generating collision-free trajectories in cluttered environments. Users define start and goal states, collision pairs for obstacle avoidance, and state spaces (e.g., joint or Cartesian) to compute paths using planners like RRT or PRM variants, with optimizing extensions such as RRT* ensuring asymptotically optimal solutions that minimize path length or energy over iterations. These trajectories can incorporate kinematic constraints via integration with the IK solver, for instance, generating joint-angle sequences for pick-and-place operations while respecting joint limits and avoiding obstacles.[20][21] CoppeliaSim supports synthetic vision sensors, including cameras and proximity detectors, for general simulation and perception tasks. Collision and distance calculations are handled through dedicated libraries that pair with OMPL to evaluate potential paths, ensuring trajectories remain feasible by checking pairwise entity interactions during planning. This integration allows for validation of planned motions in simulated dynamic environments, where kinematic chains interact with physics-based elements to test robustness against unforeseen perturbations.Programming and Integration
Scripting languages and APIs
CoppeliaSim supports embedded scripting primarily through Lua, which enables direct control and customization of simulations within scenes and models. Lua scripts are integrated as embedded components that are saved and loaded alongside the scene or model, allowing for scene-specific behaviors without external dependencies. These scripts operate via a callback mechanism, where specific functions are invoked during simulation events such as initialization, actuation, sensing, or cleanup, ensuring precise timing and synchronization with the simulation loop.[22] Child scripts, a subset of embedded scripts, include main scripts that oversee overall scene management, simulation scripts that handle per-simulation-step tasks like object manipulation or sensor data processing, and customization scripts that allow users to tailor default simulation behaviors, such as modifying physics parameters or adding custom logic.[22] Scripts can run in threaded or non-threaded modes, with Lua providing access to the CoppeliaSim API through functions prefixed withsim., such as sim.getObjectPosition for querying object states, facilitating fine-grained control over simulation elements like robots, sensors, and environments.[22]
In addition to Lua, CoppeliaSim offers APIs in seven programming languages—Lua, Python, C/C++, Java, JavaScript, MATLAB, and Octave—to support diverse development workflows and integration needs.[1] [14] The regular API, accessible in these languages, provides a core set of functions under the sim namespace for tasks like object manipulation, scene querying, and simulation control, enabling developers to extend or automate simulations programmatically.[23] For instance, Python and C/C++ bindings allow for high-performance computations or machine learning integrations directly within the simulation framework, while MATLAB and Octave support numerical analysis and prototyping common in academic research.[23] Java and JavaScript cater to web-based or enterprise applications, all while maintaining compatibility with the simulator's physics and kinematics engines.[23] Rust support is available via a community-developed ZeroMQ remote API client, acknowledged in the official documentation as of version 4.10.0 (May 2025).[24]
The Remote API extends these capabilities for external control, allowing applications in the supported languages to connect to a running CoppeliaSim instance over networks or processes, thus decoupling simulation logic from the core simulator. It supports both synchronous modes, where API calls block until completion for predictable sequencing, and asynchronous modes, which enable non-blocking operations for real-time responsiveness in complex scenarios like multi-robot coordination.[25] Implementations include the ZeroMQ-based Remote API for languages like Python, C/C++, MATLAB, Octave, Java, and Lua, and the WebSocket-based version for JavaScript, both mirroring the regular API's functionality to simplify external scripting.[25] This setup is particularly useful for offloading intensive computations, such as image processing from vision sensors, to external hosts while maintaining seamless simulation interaction.[25]
For interactive development and debugging, CoppeliaSim includes a read-eval-print-loop (REPL) functionality through the commander plugin, which adds a text input field to the status bar for executing Lua or Python commands on the fly. Implemented via the simCmd plugin, the REPL allows users to test API calls, inspect simulation states, or prototype scripts without restarting the simulator, supporting rapid iteration in both embedded and remote contexts.[26] This feature enhances accessibility for experimentation, with outputs displayed in the console or status bar, and interpreter switching between Lua and Python for flexibility.[26]
Middleware and plugins
CoppeliaSim supports integration with external middleware through dedicated plugins that facilitate communication with robotics frameworks. The simROS plugin enables CoppeliaSim to function as a ROS node, allowing bidirectional exchange of data via topics, services, and publishers/subscribers over a network.[27] Similarly, the simROS2 plugin provides analogous support for ROS 2, including actions, to enable distributed simulations and control from external ROS-based systems.[28] These bridges are implemented as shared libraries that mirror the respective ROS APIs, ensuring seamless interoperability without requiring custom code for basic topic/service communication.[29] For distributed and remote control, CoppeliaSim employs the ZeroMQ remote API, which uses the ZMQ plugin to connect external applications—such as Python, C++, or Java programs—to simulations in stepping or continuous modes.[24] This extension supports hardware-in-the-loop testing by allowing real-time synchronization between physical devices and simulated environments, as demonstrated in early framework designs for scalable robot simulations.[2] The API leverages ZeroMQ's messaging capabilities for low-latency, asynchronous communication, making it suitable for multi-robot or remote hardware scenarios.[30] CoppeliaSim's plugin architecture allows users to develop custom extensions in C/C++ as shared libraries, loaded dynamically via theloadPlugin function to add new features like hardware interfaces or specialized algorithms.[31] Built-in plugins include simVision for processing vision sensor data, such as simulating LIDAR and omnidirectional cameras, and simBubble for handling custom data processing tasks within models.[32] These plugins integrate directly with the simulation loop, enabling efficient extensions for perception and computation without altering core functionality.[31]
Add-ons complement plugins by providing script-based extensibility, typically in Lua or Python, that load automatically at startup to support specialized tasks.[33] For instance, VR integration is achievable through add-ons like the CoppeliaSim VR Toolbox, which connects simulations to OpenVR-compatible devices for immersive interaction and feedback.[34] Lua scripting can be used to control these add-ons, ensuring modular control over middleware behaviors.[33]