Skip to Content


Category: BotQueue


Automated Digital Manufacturing w/ BotQueue

One of our main users of BotQueue, 3Distributed, send in this cool blog post describing their setup. Hugh’s company makes and sells RepRap kits, which includes many 3D printed parts. In order to keep up with demand, they have a fleet of machines to print out the parts they sell. This fleet is now at 5 bots, and they use BotQueue to keep it running. Since BotQueue has an API that allows you to add jobs, they integrated their online store with their BotQueue account so that it automatically creates new print jobs when someone places an order for a RepRap machine. Completely automated, just-in-time digital manufacturing on the cheap. Awesome!

Check out the video:


BotQueue 0.4 – Easy Online Config

This latest release of BotQueue brings a lot of nice features under the hood that will make it much easier to get bots up and running. The biggest change is that all bot configuration now happens via the web interface. No more editing of config.json. You can now edit your bot config via the web, and the client will detect the changes and pull in the new config. It will be changed automatically, so no need to restart bumblebee or anything. Just make your changes on the web and thats it.

Edit Bot - TestBot - DevQueue

Since the configs get pulled from the internet, you need to assign each bot to a particular client. In the apps area, it lists all the client tokens you have and you can now rename them to reflect what computer it corresponds to. If you don’t know what computer is which, you may want to revoke all the tokens and start over, especially since the new client configuration process is so much easier.

BotQueue.com_ Internets + Digital Fabrication = Win

BotQueue now supports headless clients much better. The standard authorization process of following a link still exists, but BotQueue will now detect any token requests that originate from the same IP as your browser and allow you to accept or deny them. For most people on a home router with NAT, this means any device on your home network will have the same global IP. For user experience, this means you simply run bumblebee and then visit the website to approve it and then do all the config via the web interface. Easy and simple.

Last, but not least, BotQueue now includes a device scanning feature. This is critical for the online config process and makes setup extremely easy. The Bumblebee client will scan once on startup, and will scan every time the hardware changes (such as adding or removing a webcam). It will upload this data to the website and allow you to configure your machine by simply selecting the serial port from a dropdown and clicking on the image of your desired webcam. Can’t get much easier than that.

Here’s a full list of the changes direct from the changelog. Enjoy!

v0.4 – Online Config – July 4th, 2013

* WEB – record local and remote IP when getting bot updates
* WEB – show IP addresses on bot view page
* WEB – added 30 day list to leaderboards
* WEB – bulk create multi-job prints from an uploaded .zip file
* WEB – add support for .zip files to file view page
* WEB – add support for showing parent files to job page
* WEB – pull in all files from style urls
* WEB – add ‘bump’ feature to move a job to the top of the queue
* WEB – record client name and version when updating bot status.
* WEB – show all apps requesting access from your current IP.
* WEB – if you’re on the same IP, high likelihood its your bot
* WEB – remote address is pretty tough to fake too.
* WEB – add name info to app registration
* WEB – Remove access token for a certain app.
* WEB – Implement getmybots api call
* WEB – Implement botscanresults api call
* WEB – Allow user to manually add new machines & configure them (serial port, speed, etc)
* WEB – ability to assign each bot to an app.
* WEB – online editing of bot configs.
* WEB – add contrast and brightness configuration settings to driver config
* WEB – prevent editing of driver unless bot is offline, idle, error, or qa
* WEB – fixed error with field size for storing temperature logs.
* WEB – allow renaming of jobs
* WEB – fix register bot section.
* WEB – app token should list bots
* WEB – bot view page should show app token
* WEB – better flow for app approval -> bot registration
* WEB – if no device scan is detected on the driver page, show an error/warning message.
* WEB – update help docs with new configuration setup.
* BUMBLEBEE – report local IP address
* BUMBLEBEE – headless app authentication support – based on IP
* BUMBLEBEE – new machine discovery
* BUMBLEBEE – send list of serial ports and webcams to site for bot configuration.
* BUMBLEBEE – pull list of bots + config from web directly
* BUMBLEBEE – add contrast and brightness configuration settings to webcam
* BUMBLEBEE – update worker thread when config changes.
* BUMBLEBEE – stop worker thread when bot is removed from our list.
* BUMBLEBEE – don’t show bot list until we’ve scanned devices.
* BUMBLEBEE – linux webcam detection.
* BUMBLEBEE – add name parameter to create job api calls
* BUMBLEBEE/WEB – per-driver can slice configuration via website

If you’ve made it this far, its only fair to let you know whats next. The big features planned for v0.5 are cloud-based slicing, and timelapse generation for prints. Both of those features should be really sweet. Of course you could always read our ROADMAP to see whats coming up.


Compiling Slic3r on Raspberry Pi

The Raspberry Pi makes a great little controller for BotQueue, but it until I add cloud based slicing, the gcode generation needs to happen on the Pi itself. Since the Raspberry is on the ARM architecture, there is not precompiled version available to use. The good news is that its pretty easy to install from source.

The first step is to install the prerequisite software using apt-get:

sudo apt-get install git-core build-essential libgtk2.0-dev libwxgtk2.8-dev libwx-perl libmodule-build-perl libnet-dbus-perl cpanminus libextutils-cbuilder-perl gcc-4.7 g++-4.7 libwx-perl libperl-dev

The next step is to compile and install all the Perl dependencies. Be warned, that this next step will take literally HOURS. My advice is to install screen first and then do it within a screen session in case your login gets interrupted:

sudo apt-get install screen
screen -dR botqueue

Now, install those dependencies:

sudo cpanm AAR/Boost-Geometry-Utils-0.06.tar.gz Math::Clipper Math::ConvexHull Math::ConvexHull::MonotoneChain Math::Geometry::Voronoi Math::PlanePath Moo IO::Scalar Class::XSAccessor Growl::GNTP XML::SAX::ExpatXS PAR::Packer

To compile all of the dependencies for Slic3r, you need the GUI running. If you keep that turned off on your Pi, you need to install the virtual framebuffer to give it a ‘fake’ X server to run on:

sudo apt-get install -qy xvfb
sudo Xvfb :1 &
sudo env DISPLAY=:1 cpanm Wx
sudo killall Xvfb

Now that all the prerequisites are installed, you can install Slic3r itself:

git clone
cd Slic3r
git checkout 0.9.9
sudo perl Build.PL
sudo ./Build install

Once you’ve installed it, you can run it from the commandline with ./ Of course I sort of lied earlier… there are no officially available Raspi versions of slic3r available, but we do bundle one together with BotQueue itself. This binary can be created with the following command:

pp -c -o slic3r -M Method::Generate::BuildAll

I hope this helps anyone out there who is trying to get Slic3r installed on their Raspberry Pi!


BotQueue v0.3 = Webcams, Pausing, and More!

DevQueue - Internets + Digital Fabrication = Win-2

Update: there were a couple bugs with the client. I’ve released a new version you can download here.

Coming quickly on the heels of the last release, the latest v0.3 release of BotQueue adds some really exciting new features that make it much nicer to use. I hope you enjoy this new version as much as I do. Be careful though, the new webcam feature is addictive – you can watch your machine from anywhere you have an internet connection and a display.

If you want to take advantages of the new BotQueue, you’ll need to upgrade the BotQueue client, bumblebee. See instructions at the end of the article for how to do that.

Webcam Support

This is the biggest new feature for BotQueue, and the one that I’m most excited about. The BotQueue client, Bumblebee, can now grab webcam images and upload them to the BotQueue site. This allows you to be able to see whats happening on your bot through the website. That’s right, you can see how your bot is printing from any device (computer, phone, tablet, etc) from anywhere in the world.

I’ve also modified the dashboard and various pages throughout the website to support showing the webcams. The default dashboard view is now large thumbnail images, although you can switch to medium, small, and the old list-style view of your bots. BotQueue will also save the final image of each job so you can have a historical view of how each print turned out. In the future, we’ll even be able to automatically create timelapse videos of each job.

In order to add webcam support, please see the help page with information on how to configure bumblebee to start capturing and uploading webcam images.

DevQueue - Internets + Digital Fabrication = Win-4

Job Pausing

It happens fairly rarely, but sometimes you need to pause a job mid-print to do something. Maybe a nut fell into your print, or maybe you need to reach your hand in to clear out some debris. Well now you can pause and unpause a job from the website. Due to the magic of the internet, the request will filter down to your bot whether you are in the same room or on the other side of the planet. Due to the way this is currently done (polling HTTP requests) the lag is pretty bad (~30 seconds). Future versions of BotQueue will be implementing Websockets and should be MUCH faster.

DevQueue - Internets + Digital Fabrication = Win-1

Bot and User Leaderboard

I’m a huge fan of stats, and once you have stats you can start doing what every primate has done ever – compare him/herself to others! Well, the BotQueue stats page now has a leaderboard for both bots and users. How does your bot stack up? Are you logging the most hour and producing tons of stuff with your machines? Head on over to the stats page and see how you stack up!

Overall Stats - DevQueue-1

Job Commenting

This is a pretty straightforward feature that allows you to make a comment on any job. Use it for making notes on output quality, or just helping you keep track of what is what. If you add a comment, the job detail page will show a badge next to the comments tab to let you know that there are comments when looking at the job.

View Job - material-180x190x8.gcode - DevQueue-1

Upgrading Bumblebee

Since BotQueue v0.3 adds webcam support, and this requires some new software to make it all happen. For Linux, we’ll need to install fswebcam. If you’re on OSX, you don’t need to do anything – the webcam support is bundled in the new version of bumblebee directly.

You’ll also need the new version of bumblebee which can be downloaded here. Simply unzip the folder and run the bumblebee program like normal. You will need to copy your config.json file over and modify it with your webcam information as described in the help area.

If you’re on Raspberry Pi, your bumblebee software has been downloaded using git. For you, upgrading is really easy. Open a terminal to your Pi and enter these commands to upgrade, modify your config file, and then reboot:

sudo apt-get install fswebcam
cd ~/BotQueue
git pull
git checkout 0.3
nano bumblebee/config.json
sudo reboot


* WEB – add ability to make comments on individual jobs
* WEB – fixed a major security flaw that allowed people to see your jobs
* WEB – add organization to job view page – tabs?
* WEB – add canceled status to jobs & remove all calls to delete()
* WEB – Allow pausing / resuming through website
* WEB – create job time logging table to better track time spent in jobs (and be able to handle errors, dropped jobs, and canceled jobs)
* WEB – create script to populate job_clock with times from existing jobs.
* WEB – create job_clock entry on start of job.
* WEB – close job clock entry on job drop
* WEB – close job clock entry on job finish
* WEB – update main stats page to reflect job_clock times
* WEB – update bot stats page to reflect job_clock times
* WEB – update queue stats page to reflect job_clock times
* WEB – added leaderboard to stats page.
* WEB – update time displays to include more digits (eg: 1.2 hours vs 1 hour)
* WEB – add source info for jobs added by url.
* WEB – added webcam display to dashboard, bot, and job.
* WEB – modify dashboard ajax to preload images and then fade-in new content
* WEB – add ajax selector for 4 different views: details, big thumbs, med thumbs, small thumbs
* WEB – add ajax checkbox for turning on/off auto-update.
* WEB – add ajax call to save dashboard style stuff
* WEB – fix top navigation to show what page/area you are at
* WEB – update help instructions to add webcam config info
* WEB – get real default image for bots w/o webcam

* BUMBLEBEE – allow pausing and unpausing based on api status change.
* BUMBLEBEE – added webcam uploading during idle and printing periods
* BUMBLEBEE – fix race condition when workerbee is changing the status of the bot
* BUMBLEBEE – add watermark to each image
* BUMBLEBEE – resize each image to 640×480
* BUMBLEBEE – save each image at 60% quality (jpeg)
* BUMBLEBEE – compile slic3r and update install script


BotQueue Update – Raspberry Pi + Temperature + Dashboard

I’ve been logging quite a few hours lately with BotQueue, and as a result of that I’ve been tweaking and modifying lots of things. I’ve hit a few major goals, so its time for a new release! The new features and reliability stuff make this release extremely usable, and it shows – I’ve logged about 100 hours in the last 2 weeks and plan on adding 2 more printers to my queue to really get some printing capacity going. On a related note, over 1000 hours of printing and CNC cutting have been logged through

More Robust Bumblebee

I’ve done a ton of work to Bumblebee, the client that runs your 3D printer. I live in China, so internet can be spotty at times haha. As a result, I’ve encountered just about every error imaginable – and made Bumblebee tolerant of it. The result is that it is MUCH more reliable. You can either run from github or download the v0.2 release. No new configuration required – just download the new files, copy over your config.json and run the new Bumblebee. Voila, upgraded!

Cancel Jobs From the Web

This was a huge gap in functionality for BotQueue that has been closed. You can now cancel a job from the website and it will notify Bumblebee which will then stop the job. You can take the bot offline, or just clear the printer of a failed job and it will start it again. I’ll be adding pause/play functionality soon as well for even more interactive control of a Bot.

Drop Job - DaYin - butterfly.stl __

New Dashboard

The dashboard has been overhauled with an eye towards the common tasks you encounter when using Botqueue on a daily basis. You can create new jobs/bots/queues, see all the critical information on running jobs (like temperature) as well as upcoming and finished jobs. You can re-arrange upcoming jobs, and you can re-run old jobs. Life is good.

Temperature Logging

This is a feature I’ve been wanting for a while now. Using the awesome Flot library and by pulling the temperature data from the machine we can now log and display temperature data for all jobs going forward. Super helpful if you want to see how a machine is doing, or a job fails mysteriously and you want to see if the temperature was the culprit. It will also now show the temperature data on the dashboard which is very helpful during warmup when the percentage sticks at 0.01% for the first 10 minutes – you can now see the bot heating up from the web.

View Job - butterfly.stl __

Slic3r 0.9.9

In a fortuitous timing coincidence, the new Slic3r has been released. This new version adds some cool features, and if you use BotQueue you can easily upgrade. Just remember to re-export your config from the new Slic3r in order to pick up any new settings in the new version. You’ll need to select the new slice engine and slice config in as well.

Slic3r - About-1

Raspberry Pi Support

I was a bit skeptical at first, but at the prodding of Jnesselr I took the plunge and got a Raspberry Pi. Holy crap, this thing is AWESOME as a machine controller. It’s pretty easy to setup, and once you have it running, it is amazing. I have put one of these babys on each of my machines and it is so awesome to just have Botqueue built in with no computers or extra stuff. Each machine just has a ethernet cable and a power cable. WiFi works, but I couldn’t find a decent dongle so I’m sticking with wired for now. Slicing is a bit slow, but there are plans to address that in the future. The Pi is a great platform, so expect lots more support for it in BotQueue in the future.


More to come

We’ve got a big, long list of awesome stuff to add to BotQueue. In particular, I’m really excited about webcam support, web-based configuration of bots, and an on-deck system to anticipate and pre-slice models to make the whole BotQueue slicing system more seamless and faster. As always, please submit bug reports to the Github issue tracker and remember to Keep it Locked!


BotQueue v2: Slic3r Integration

BotQueue version 1 was a great proof of concept.  You could upload gcode files, and they would be distributed across multiple machines for printing.  It served that purpose well, and I received great feedback from the community as a result.  In particular, a major request was to integrate slicing into the BotQueue flow so that a user could upload an STL file directly.

Well, ask and ye shall receive!  Today I’m proud to announce that BotQueue now supports online slicing with Slic3r, the wonderful open source slicing tool.  With this release of BotQueue, we are supporting the latest version of Slic3r (0.9.8) although if there is interest, I could add support for previous versions of Slic3r as well.

Here’s a quick overview of how this process works:

  1. You upload an STL or OBJ file to
  2. Bumblebee (the BotQueue client) downloads and slices the 3D model into GCode.
  3. Bumblebee uploads the GCode back to the site for re-use by your other printers w/ the same config.
  4. Bumblebee executes the GCode created by Slic3r.

Now, what if a slicing job goes wrong and Slic3r reports some errors?  This is where two wonderful open source projects come to save the day.  First, the wonderful Thingiview.js plugin by Tony Buser. Second, the most excellent GCode Viewer plugin by Joe Walnes. If there is a problem with the GCode parsing, BotQueue will take you to a page where you can view the model and the gcode output to verify if it is correct or not.  Both of these plugins require WebGL to function properly, so make sure you have the latest FireFox, Chrome, or Safari installed.

Verify Job - SnakePin_50mm.stl __

This latest feature has been designed with you in mind.  I know that everyone has their favorite slicing engine, and their own custom configuration file.  BotQueue makes it ridiculously easy to manage all that.  The new slicing functionality is based around the idea of SliceEngines and SliceConfigs.  A SliceEngine is something like Slicer-0.9.8 or Skeinforge-0050.  A SliceConfig is the unique settings that you decide for a SliceEngine.  You can have as many SliceConfigs as you like.

Each bot is configured to use a particular SliceConfig. When a bot grabs a new job, it will start the slicing process.  First, it looks to see if that particular model has been sliced with its assigned SliceEngine and SliceConfig.  If it finds that, it can skip the whole process and use the pre-sliced gcode.  If not, it will download the 3D model and slice config and then slice the model into GCode accordingly.  Once it finished the slicing, it will proceed to print the resulting gcode.

This is awesome in so many different ways.  Let me count them for you:

1. All you do is upload an STL and it will automatically get printed.  Configure your bots once and then FORGET ABOUT SLICING FOREVER.

2. You can have 1 slice profile tuned to each bot, and BotQueue will intelligently choose the right engine and config to use when slicing.  No more dealing with 4000 configs and remembering what is what.

3. If you change a config, you can “expire” previously sliced jobs.  No more stale GCode files laying around.

4. Online viewer for both the GCode and 3D model.  You don’t need to install any client software just to look at a print job.

Currently Supported Slicing Engines:

  • Slic3r-0.9.8
  • older versions of slic3r on request
  • Pull requests to add new slicers gladly accepted!

Important – Upgrading to v2

First, get Slic3r running. BotQueue is currently on 0.9.8 and we’ll be continually adding whatever the latest version is.  After that, you will need to upload your configuration(s) to BotQueue from the relevant slice engine page. You can export the config from within the Slic3r program. If you don’t have a config for Slic3r, then the default one is a good place to start.  You will use Slic3r to change any configuration options, or you can edit the config by hand online.

Second, edit your bots in the web interface and choose the appropriate slice engine and slice config for each bot.

Third, upgrade your BumbleBee installation to version 0.1.0.  Download the file, extract it, and then run it from the commandline like normal. You will need to copy over the config.json file from your old Bumblebee install.

Congratulations, you can now slice and print jobs through the internet.

Warning: The previous BumbleBee from v1 is now obsolete.  Do not use it again!  Delete the old folder!


Introducing BotQueue: Open Distributed Manufacturing

With the advent of cheap, low-cost 3D printing there are now fleets of 3D printers in operation.  In my previous life as co-founder of MakerBot Industries, I have dealt with running one of those fleets.  I can attest to the fact that it can be a pain in the butt.  You are basically forced to use software that is designed to control a single machine, and you end up with control windows everywhere.  Close one of them accidentally and you just hosed a build.  Not cool.

I believe that low cost 3D printing has the potential to revolutionize not just prototyping, but small-scale manufacturing of parts: from 10 to 1000 units.  With a small fleet of 3D printers it is possible to run them around the clock and produce enough parts to run a small business.  While this has been possible before today, there has never been software designed with this task in mind.

Thus, BotQueue was born.

BotQueue is an online platform for distributing print jobs to multiple 3D printers for production.  As the name suggests, it allows you to create a print queue which contains jobs.  Your connected bots will grab jobs and produce them.  As each job is competed, the operator is prompted to remove and verify the output.  Upon successful completion, the bot will grab the next job and start producing it.  This continues until the queue is empty.  If a bot fails, it is taken offline for repairs.

Another huge benefit of BotQueue is online access to your bots.  The main interface to control your machines is through the BotQueue website.  This means you can access your bots from anywhere in the world.  You could queue up a print while on the road, and come home to a finished object on your 3D printer.  Future support is planned for webcams, so you will even be able to check up on the printing progress remotely.

The best part of all this?  It’s 100% completely open source.  Both the web server and client software are licensed under GPLv3.  An instance of the BotQueue server is being hosted on, but you are free to run your own local server for private production, a public server for hosted printing, or whatever you want.  The code is located at

BotQueue is designed for running machines as close to 100% capacity as possible.  However, it would work just fine for everyday single-machine, sporadic use.  It would also work well for putting development machines through life testing as it tracks failures, printing time, and general usage statistics.

This is the v1.0 release of BotQueue, so it may be a little bit rough around the edges.  Currently it only supports RepRap machines running gcode-parsing firmwares such as GRBL, Sprinter, Marlin, etc.  Future support is planned for MakerBot machines.  The client has a driver-based architecture and is written in Python, so it is straightforward to add support for new machines or firmwares.

To get started, visit the apps page for information on how to download and install the BotQueue client aka Bumblebee.

Oh, and one more thing.  BotQueue has an API for most operations such as adding jobs, grabbing jobs, etc.  Want to integrate your distributed manufacturing center with your sales system?  Have at it!