A Full-Stack Robotics Development Environment
Alternatives To Bowlerstudio
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Habitat Sim1,760
2 days ago129mitC++
A flexible, high-performance 3D simulator for Embodied AI research.
14 days ago1April 27, 202219otherC++
C++ implementation of Lie Groups using Eigen.
16 days ago16otherPython
(IROS 2020, ECCVW 2020) Official Python Implementation for "3D Multi-Object Tracking: A Baseline and New Evaluation Metrics"
a year ago71mitPython
Deep Hough Voting for 3D Object Detection in Point Clouds
3 days ago2February 28, 202227mitC++
A small C++11 header-only library for Lie theory.
Frustum Pointnets974
3 years ago63apache-2.0Python
Frustum PointNets for 3D Object Detection from RGB-D Data
Xviz929452 months ago22June 02, 2022162apache-2.0JavaScript
A protocol for real-time transfer and visualization of autonomy data
2 years ago2bsd-2-clause
Index repo for Kimera code
Pytorch Dense Correspondence460
2 years ago9otherPython
Code for "Dense Object Nets: Learning Dense Visual Object Descriptors By and For Robotic Manipulation"
a month ago4otherC++
[IROS 2021] BundleTrack: 6D Pose Tracking for Novel Objects without Instance or Category-Level 3D Models
Alternatives To Bowlerstudio
Select To Compare

Alternative Project Comparisons


Join the chat at Build Status Github All Releases

CII Best Practices

Download Latest

Ubuntu 18.04

sudo add-apt-repository ppa:mad-hephaestus/commonwealthrobotics -y
sudo apt-get update
sudo apt-get install bowlerstudio


sudo apt-get install software-properties-common python-software-properties					
sudo add-apt-repository "deb xenial main" -y
sudo apt-key adv --keyserver hkp:// --recv-keys 71EA898B 
sudo add-apt-repository "deb bionic main" -y
sudo apt-get update
sudo apt-get install bowlerstudio

What is BowlerStudio?

BowlerStudio assists you in every step of a robotics project from concept to completion. Tools enable users to:

  • Interface with motors, sensors, and other electronics hardware.
  • Create 3d models for fabrication, and for simulating the motions of your project.
  • Give your robot sight with image processing on camera feeds and Kinect data.
  • Operate 3d printers and other CNC machines.
  • Create custom graphical user interfaces to control yours robots.
  • Create and control animations.


The Nitty-Gritty Version

BowlerStudio Robotics development IDE is based on

BowlerStudio is a device manager, scripting engine, CAD package, and simulation tool all in one application. A user can develop the kinematic of an robot arm using the D-H parameters-based automatic kinematics engine. With this kinematics model, the user can then generate the CAD for new unique parts to match the kinematic model. The user can then export the model to an STL, and connect a Bowler 3d printer to BowlerStudio. The printer can print out the part (using the newly generated STL) while the user connects a DyIO and begins testing the servos with the kinematics model. When the print is done, the user can assemble the arm with the tested servos and run the model again to control the arm with Cartesian instructions. Once this is complete, the user can then attach a wiimote to train the robot arm through a set of tasks, recording them with the animation framework built into BowlerStudio. To be sure the arm is moving to the right place, the user can attach a webcam to the end and use OpenCV to verify the arm's position, or use the arm (in conjunction with the webcam with OpenCV enabled) to track and grab objects (IE "eye-in-hand" tracking).

Every step of this task can be performed from within BowlerStudio!

Let's go through the main features:

Scripting With Gist

About scripts and Gist

Scripts are bits of code that BowlerStudio can load and run. BowlerStudio allows you to open a local file and run it, but BowlerStudio is most powerful when the code lives on Github Gist (a code snippet hosting service from Github). Simply give BowlerStudio the URL for a Gist you want to load and execute. Gists can be selected and edited using the built in browser, or inline in another script using the Gist ID.

Java and Groovy

BowlerStudio can load and run scripts written in Java, Groovy, and Python. Which parser is used is determined by the file extension. Files that end in .java or .groovy will be run through the Groovy compiler. These Groovy scripts are compiled fully and run directly in the JVM. This means they will execute at full speed, just like a regular application.


Python, on the other hand, by virtue of its structure, will generally execute much slower then Java. With the reduction in speed you get lots of flexibility and a clean and easy to understand syntax. The python code can also create and return objects to BowlerStudio (such as CAD CSG objects, or UI Tabs).

Return Objects

A script can return a few object types that will be handled by BowlerStudio: Objects of type "CSG" and "MeshView" will be added to the 3d display. If a transform is added to either of these and updated by a script the user can move an object in the 3d view. Objects of type "Tab" will be added to the Tabmanager and displayed in BowlerStudio. This is an easy way to make control panels or state displays and monitors. Objects of type "BowlerAbstractDevice" (or any subclass) will be added to the connections manager and made available to all other scripts. These can be external devices or virtual communication bus devices. A bowler Server/Client pair is the preferred mechanism for communication between scripts.

Device Access

All scripts are passed all connected devices by name when the script is run. The name associated with the device in the connections tab is the name to use in the script to access that device. A script can also create and return a device (EG to connect to a specific device in order to give that device a specific name). The device returned will be added to the list of available devices and be available to other scripts. A user can define their own devices to facilitate communication between scripts.

Bowler Devices

BowlerDevices (such as the Neuron Robotics DyIO) are devices that implement the Bowler Communication System. BowlerDevices are servers of features to applications. The DyIO, for example, is a server of microcontroller features. These devices implement a micro domain-specific language as a protocol. This language synchronizes the device with the application by building the communication system at runtime using a namespace/RPC system. As such, the device is treated as a collection of namespaces. Each namespace has a set of RPCs for communication, some synchronous (IE they are application initiated) and some asynchronous (IE device initiated). In addition, each RPC has full method introspection. This means that all parameters and datatypes (including how to pack and interpret all packets) are able to be queried over the communication system. A Library need only implement the core packet parser and every device will assemble its own communication layer live.


Cameras can be connected to Bowler Studio using one of 3 supported drivers: OpenCV's native Java bindings are provided by installing OpenCV using your OS specific installer (unfortunately not available for Mac at this time). JavaCV is a meta-library that adds support for a wide range of camera device integrations and image processing options. This is a big project and integrated now with a full scripting system. CHDK-PTP-Java is a Java library that adds support for SLR Cannon cameras. CHDK is a camera OS that makes the cameras features available over USB, and the Java library makes those images and controls available to Java and or scripting engine.

Image processing

Image processing is provided be a variety of libraries included in this application. OpenCV and ARToolkit are some of the most widely used image recognition libraries available, and now you can use them directly from our scripting environment!

Kinematics Engine

The Bowler Kinematics engine is based on D-H parameters- the standard mathematical definition of kinematics chains. This standard simplifies the calculation process and allows us to run forward kinematics equations for arbitrary defined chains in real time. For inverse kinematics, a collection of kinematic engines are available for optimizing for speed and accuracy.

Real-Time validated

For applications where real time is required, there is no need to leave the Bowler OS. The Bowler Java stack has been validated as real-time capable when run on JamaicaVM (the real-time Java implementation). The Bowler Kinematics engine is run in a real-time loop for neurosurgery applications (Bowler and Java are fast and reliable enough for brain surgery!)


Users can write scripts using Java, Groovy or Python to generate CSG style CAD. This programmatic CAD engine JCSG was inspired by OpenSCAD, but implemented in pure Java with JavaFX visualizations. JCSG implements all basic shape generation and manipulation, using Java's library packaging and distribution for libraries of parts. Gist hosting of parts can also simplify sharing and loading of dependent libraries.


Virtual links

Virtual PID devices allow users to make applications that can be simulated with virtual links before ever connecting a real device. Users can also use the PIDLab to learn about designing and implementing PID controllers with a built in motor physics simulation.

Virtual Camera

Coming soon! Soon users will be able to interact with the 3D environment camera from their code just like a real camera. Users will be able to manipulate it just like it was another 3d object.

Virtual Sensors

Coming soon! Soon we will be able to provide virtual sensor devices, simulating real world sensors within the 3d environment.

Make A Contribution

BowlerStudio is an open source project and is always looking for help with both the application code and the tutorials content.

Java Contributions

If you are a Java developer, skip ahead to The Build Instructions. The application is a light plugin framework for UI, 3D and Device interaction. You can look at this repository for issues.

Adding Tutorials

All of the content for BowlerStudio Tutorials is housed on our web page. Fork that repository and make contributions based on the file in the root of the repository. To merge the changes into the main website, send a pull request with your changes to official repository.

Examples of tutorials that need to be added are A simple Java Programming Introduction. This tutorial set would go through the basic syntax of java and what all of the symbols mean and how to use them.

Another example of a tutorial that could be added is one for JavaCad Cheatsheet where you would add a 'cheat sheet' of commands to use in the JavaCad system.

If a tutorial is missing and not described as needed by an issue, feel free to add additional issues.

How to Build BowlerStudio


  • Java >= 1.8
  • Internet connection (dependencies are downloaded automatically)
  • IDE: Gradle Plugin (not necessary for command line usage)
  • OpenCV 2.4.9 installed and configured in the library paths (OS installers preferred)
  • The Binary installer for BowlerStudio must be installed before develpment.


Open the BowlerStudio Gradle project in your favorite IDE (tested with NetBeans 7.4) and build by calling the assemble task.

Command Line

Navigate to the Gradle project (e.g., path/to/BowlerStudio) and enter the following command:

Bash (Linux/OS X/Cygwin/other Unix-like shell)

Ubuntu 18.04 Dependencies
sudo apt install  curl
Ubuntu 16.04 Dependencies
    sudo apt-get install git gradle
Ubuntu 14.04, install extra dependencies
	sudo add-apt-repository "deb xenial main" -y
	sudo apt-key adv --keyserver hkp:// --recv-keys 71EA898B 
	sudo add-apt-repository "deb trusty universe multiverse"
	sudo apt-get update -qq
	sudo apt-get install -y --force-yes gradle 
All Unix
    bowlerstudio # run this to get the JVM downloaded into $HOME/bin/java8/jre

    git clone

    export JAVA_HOME
    cd BowlerStudio
    git checkout development
    git submodule update --init --recursive
    git submodule update  --recursive
    ./gradlew shadowJar
    $JAVA_HOME/bin/java -jar build/libs/BowlerStudio*.jar

Now you can use the Eclipse Marketplace to install the Gradle Plugin

Windows (CMD)

gradlew jar


Bowler Studio began Feb 11, 2015 with the goal of making a robotics IDE.

Popular Robotics Projects
Popular 3d Graphics Projects
Popular Artificial Intelligence Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
3d Graphics
Java Library
Physics Simulation