What is it?

Project MoNET is a hybrid software/hardware platform for creating interactive art.

It consists of:

  • a web application that allows users (the crowd) to create color samples using the camera on their mobile device.

  • A robot that reads those color samples and then paints them in real time to canvas.

Additionally the Project MoNET web app was designed with flexibility in mind and could potentially create a painting from any type of input (images, arbitrary data, music, etc). The robot may be easel mounted (for painting on canvas) or wall mounted (for murals) and is built to be easily scaled up or down from its current size.

Who Built It?

The Project MoNET team is Gareth Warren, Richard Zacur, and Jack Heaton.

Why did we build it?

The members of the team met at a local meet-up for FreeCodeCamp. We all thought that the FCC curriculum was great, but we wanted to do something a little less abstract than the exercises we were working on.

Additionally, we all had an interest in hardware hacking, so we knew we wanted something with a physical computing aspect.

We also knew Maker Faire Pittsburgh was coming up in mid October, so that gave us a deadline to come up with something to present. It also framed the project with the idea of building something that's interactive and fun.

So, with these criteria in mind, naturally you end up building a JavaScript/Arduino powered web-driven paint spewing robot.

How did we build it?

Project MoNET was built in fits and starts over five months in the team's spare time. Build and development activities took place at TechShop Pittsburgh and at the Like Clockwork Nanofactory (a.k.a. Jack's garage).

  • The Backend
    Our web app is written in JavaScript and runs on a Node.js server. We use the following packages:


  • The Frontend
    We aren't total hipsters so our user facing pages use:


  • The Robot
    The robot uses a mix of custom built and off the shelf electronics and parts mounted onto a custom laser cut chassis. For control it uses two microcontrollers communicating over serial to operate: an Atmega328 based controller for handling stepper motor control and paint dispensing and an ESP8266 based controller to handle communications with the web application. Our robot control code is written in Arduino (C++). We use the following libraries:


  • Tools Used
    We use 100% open source tools including:
    • Atom as an IDE.
    • PlatformIO to allow us to work with microcontrollers within Atom.
    • Inkscape for vector graphic design.
    • GIMP for other graphic design.
    • LibreCAD for 2D drafting.
    • KiCad for circuit board design.

What challenges did we face?

  • We are all newbies with full-stack development so we fought the learning curve the entire way.
  • There are so many Node.js packages!
  • There are so many front-end JavaScript packages!
  • Figuring out a good solution for dispensing paint was tough.
  • We had to develop a communication protocol between the website and the two microntrollers that needed to be fast and fault tolerant.
  • Precision color mixing is still tough.
  • Paint. Freaking. Everywhere.

What are we most proud of?

  • It works!
  • Developing a working serial communication protocol between the ESP8266 and then Arduino.

What's next?

  • We are very close to having a mode that turns pictures into a painting ready.
  • Migrate to the ESP32 once the Arduino core has been completely ported to it. This chip is dual core, faster, and with a bunch more IO, so we should be able to (thankfully!) ditch our dual MCU setup.
  • We'll keep hacking on the web app to allow it turn more types of data into a semi-abstract paintings.
  • We want to open up to do commissioned paintings/murals and recover some of our build cost.
  • We'd like to build a smaller model and potentially Kickstart it.