Google Summer of Code (2011–2017)

From 2011-2017, The Processing Foundation has participated in Google’s global open-source education initiative Google Summer of Code. Through this sponsorship, we work with college-level students in open source projects that develop and expand Processing and p5.js. Students are paired with mentors from our community and are paid a stipend. GSoC projects have been as wide-ranging as library development to community outreach.

GSoC 2015 kickoff party.
Maya Man, a student mentored by Johanna Hedva in GSoC 2015, presents her work at the p5.js Contributors Conference.
New Kinect libraries openKinect and KinectPV2 by Thomas Sanchez Lengeling, mentored by Elie Zananiri in GSoC 2015.
Karen Peng and Kevin Siwoff share new work on p5.js 3D capabilities.
A browser-based code editor, designed specifically for the p5.js community, by Jason Sigal, mentored by Daniel Shiffman, in GSoC 2015.


2017 marks the Processing Foundation’s sixth year participating in Google Summer of Code, after a break in 2016. We were able to offer sixteen positions to students. We posted whole project round up on Medium.


p5.js Windows Port by Guy de Bree, mentored by Sam Lavigne
For my Google Sumer of Code I developed a Windows port for the p5.js IDE, and fixed bugs for said editor. It’s now on the p5.js website! While it still has bugs, you can try it out on the downloads page. (source code)

New Kinect libraries openKinect and KinectPV2 by Thomas Sanchez Lengeling, mentored by Elie Zananiri
The goal of the project was to expand and update the existing Kinect libraries; OpenKinect-for-Processing and KinectPV2. The openKinect library now supports the new Kinect v2 for Mac and Windows and Kinect v1 for Windows and Linux. For the KinectPV2, functionalities include: skeleton tracking, face detection, process frame raw data, point cloud extraction and contour extraction. Source sode on github: OpenKinect-for-Processing and KinectPV2. 3.0 Update by Luca Damasco, mentored by Golan Levin
Prior to the start of the Google Summer of Code, Processing’s Python mode would not work at all with Processing 3.0 due to some extensive back-end changes. Fortunately, this summer saw the revitalization and updating of Python Mode! Users may now write Processing 3.0 Sketches using Python syntax in the new editor. Due to a few outstanding bugs, it has not yet been officially released, but feel free to try it out by building the Source on your own machine. In addition to once again making Python Mode functional, I have edited over 1,000 lines of reference code as well as ported nine new tutorials! Feel free to check them out and leave feedback!

Web IDE for p5.js by Jason Sigal, mentored by Daniel Shiffman
A browser-based code editor, designed specifically for the p5.js community. The project adapts the p5.js Desktop IDE (originally by Sam Lavigne, GSOC ’14) for the web, with inspiration/insight from Gene Kogan's p5 Sandbox. The goal is to make it easy to create, browse, share, and remix creative code sketches directly from the browser. Every project gets a unique URL and version control (through GitHub Gists). Logged-in users can access their previous sketches, and all users can access curated p5.js examples. Create an account and start sketching! Demo at

Raspberry Pi and armv7hf support by Gottfried Haider, mentored by Ben Fry
Gottfried worked on making Processing play well with the Raspberry Pi and similar ARM-powered microcomputers (to borrow a term used in the 1970s to describe various kits and designs built around affordable microprocessors, such as the Motorola 6800). Initial support got merged into processing.git in time for Processing 3.0. The upcoming 3.0.1 release will contain all remaining parts, such as the bits necessary for having working OpenGL graphics on the Pi (with some great help by the JOGL team). Part of the work also involved the creation of a new core library, Hardware I/O, that was made to provide access to the hardware peripherals, such as GPIO, I2C and SPI, that are generally made available on pin headers on such systems. The hope was that using those could be as simple and straightforward as it is on the Arduino platform today. To learn more: Notes about running Processing on ARM Linux and the Raspberry Pi & Raspberry Pi 2. A short (vertical!) video clip showing the GPIOs in action.

p5.SVG and p5.PDF by Zeno Zeng, mentored by Danne Woo
The main goal of p5.SVG is to provide a SVG runtime for p5.js, so that we can draw using p5’s powerful API in svg, save things to svg file and manipulating existing SVG file without rasterization. Source code on GitHub. As for p5.PDF, it’s a simple PDF export module for p5.js based on browser's print to pdf function. (source code)

internationalization of p5.js website & collection of sketches for the p5.js community statement video by Maya Man, mentored by Johanna Hedva
This summer, I worked primarily on two separate projects. First, I rebuilt the p5.js (currently built in php) using Node.js, Assemble, Grunt, Handlebars, & YAML to support internationalization (easy tranlations from English to foreign languages // button styling to be adjusted & tranlsations to be completed at upcoming translat-a-thons). Second, I collected and currated sketches contributed from people around the world to play in the background our p5.js community statement video. Check out the projects on my github (source code below)!

i18n site source code
community sketches source code

Contribution Manager UI upgrade by Akarshit Wal, mentored by Scott Murray
Contribution Manager is a tool which lets uers install/upgrade/remove various libraries and other contributions. The aim of the project was to change UI of the Contribution Manager and make it more user-friendly. Another small part of the project was to test all the libraries and their examples to check their compatibility with Processing 3.0 and collect data about what is missing in them.

RSyntaxTextArea integration and the REPL Mode by Joel Moniz, mentored by Manindra Moharana
The RSyntaxTextArea integration aimed at replacing the JEditTextArea, which is currently at the heart of the PDE editor, with the RSyntaxTextArea and the complementary AutoComplete code completion library to bring several new features to the table, such as code folding and documentation support and parameter tabbing during auto-completion. The REPL mode adds a Read-Evaluate-Print-Loop console to processing, enabling users to type in processing code, and to view the output of this code immediately. This mode also gives the PDE the ability to hot swap code, wherein the output corresponding to changes made in a running sketch can be viewed by simply saving the sketch, without restarting it. A detailed report of everything that was undertaken this summer can be found here.

p5bots by Sarah Groff-Palermo, mentored by Shawn van Every
p5bots combines a socket layer and a simplified API to enable users to interact with an Arduino (or other microprocessor) from within the browser. Use sensor data to drive a sketch; use a sketch to to affect the real world.

p5 WebGL Renderer by Karen Peng, mentored by Kevin Siwoff
A light-weight webGL renderer for p5.js. Over the summer, basic webGL APIs for p5.js are implemented. It enables you to create sketches under WebGL mode, while all the syntaxes remain consistent with p5 2D (default) mode. WebGL APIs includes: cameras, geometries, lights, materials, texture, etc. For more detail, references are documented. Get started with p5 webGL tutorial. Take a look at 3D examples.

Video and Audio streaming library by Nick Confrey, mentored by Dan Shiffman
Thanks to Andres Coulbri and Gottfried Haider for their exceptionally helpful code and examples. Thanks also to my mentor Dan Shiffman for direction and help throughout all the weeks. This project is broken up into roughly three useful parts. It originally focused on streaming media over the network, primarily video and audio streams, but evolved to include revamping Processing's video core video framework. I planned to write networking code in Java, but the project evolved to consist of learning and developing C to Java conversion through Java Native Interface and Java Native Access. Along the way I also picked up skills in video codecs, network packet payloading, and audio encoding. The first part of the project was modifications and extensions to the existing Processing network library. The second part was upgrading Processing's video capability to use GStreamer 1.0 instead of the depreciated GStreamer 0.10 which Processing was previously relying. Finally, the Processing community can access the most recent version of GStreamer, and with it, the most recent plugins. While the code itself is highly tailored towards videostreaming and video playback, the same JNI technique can be used to access the wealth of GStreamer resources, from CD ripping all the way to audio analysis. Processing users will now have much more power in the areas of video and audio. I have also left exposed a public static void pipelineLaunch(String pipe) function, which parses a GStreamer pipeline string and then launches and runs the pipeline. The third part of the project was creating a streaming library that allows Processing users to stream local videos and songs/audio files to other sketches and other computers.


Android Mode for Processing 3.0 by Imil Ziyaztdinov, mentored by Andres Colubri
The new android mode in Processing 3.0 implements several pieces of functionality that were missing from earlier versions: Export Signed Package (with transparent handling of keystores), device selector, automatic SDK download/installation, and target SDK selector. It also fixed some critical bugs, most notably the missing javac error during package building.

Contributions Manager: Reloaded by Joel Moniz, mentored by Florian Jenett
The Contributions Manager enables easy and convenient installation, removal, and update of contributions (Libraries, Tools, and Modes) from within the PDE. This summer saw the introduction of a few new features to the Contributions Manager, such as the addition, removal, and update of Tools and Modes without a restart, a new “examples-package”-type contribution, and highlighting contributions. (source code)

Loom by Chris Johnson-Roberson, mentored by R. Luke DuBois
Loom lets you create and manipulate patterns of timed events. These patterns can be mapped to audiovisual output, transformed in various ways, and recorded to enable non-realtime synthesis and synchronized video. (source code)

New video library using GStreamer 1.x by Roland Elek, co-mentored by Levente Farkas and Andres Colubri
The aim of this project was to create a set of Java bindings for the GStreamer 1.x series, automatically generating everything where applicable, and then updating the video library in Processing to use these new bindings. We were able to solve the most challenging problem — the automatic generation of Java code directly from the GObject Introspection data — using a library called CodeModel, and BridJ as the native interoperability library. In addition to this, we modified the current Java bindings in order to run the video library with the latest stable release of the gstreamer toolkit (1.4.0), which confirms that the new gstreamer binaries (released for Windows and Mac OSX plarforms by the gstreamer organization itself) can be successfully loaded from Processing. At the time of conclusion of GSOC, the new bindings were still not ready to use as the basis of the new video library, however we are very confident that we will achieve the final goal within the next two months.

ofSketch by Brannon Dorsey, mentored by Christopher Baker
ofSketch is a barebones browser-based IDE for openFrameworks. Targeted toward new users, ofSketch decreases the openFrameworks barrier to entry by providing a “plug and play” development environment that allows users to spend more time coding and less time with configuration. In addition to its simplicity, ofSketch supports powerful extended functionality like API specific autocomplete, compilation feedback, error reporting, project export, remote coding capabilities, and Raspberry Pi support to fit the needs of intermediate coders.

p5.sound by Jason Sigal, mentored by Evelyn Eastmond, is an addon for p5.js
p5.sound brings the Processing approach to Web Audio. Its functionality includes audio input, playback, manipulation, effects, recording, analysis, and synthesis with syntax built off of Wilm Thoben’s Sound for Processing library. The project is on GitHub, with interactive documentation and learning examples on This summer, Jason also wrote methods for file input / output and ported Processing’s Table / TableRow classes to p5.

p5 IDE by Sam Lavigne, mentored by Lauren McCarthy
An easy to use desktop IDE for creating p5.js projects.

PDE X for Processing 3.0 by Manindra Moharana, mentored by Daniel Shiffman
PDE X is a Processing mode that introduces advanced IDE features like code completion, refactoring, live error checking, debugger and more. The goal of the project was to bring PDE X to a stable state and make it the default editor for Processing 3.0. The main focus was on fixing the last remaining bugs and tweaking/refining what was already present. A few new features were also introduced. Please see Manindra’s post for more details on what was accomplished. (source code)

POculus by Pratik Sharma, mentored by Elie Zananiri
POculus provides an Oculus renderer for Processing. Any P3D sketch can be made Oculus ready by using the POculus renderer. (source code)

Sound for Processing 3.0 by Wilm Thoben, mentored by Casey Reas
Sound is the new core lightweight sound library for Processing. The project started in late 2013 and in GSoC 2014 new features, bug fixes, and cross platform support were introduced. Sound uses a customized and enhanced version of methcla, a C++ sound engine. The native bindings allow for low latency support which is a new feature. Sound is a collection of sound-synthesis objects, analyzers, and effects.

TweakMode for Processing 3.0 by Gal Sasson, mentored by Daniel Shiffman
Tweak is a new execution mode in Processing 3.0 that allows changing sketch parameters in realtime. TweakMode was created last year in GSoC 2013 as a separate mode, and was brought into Processing 3.0 this summer, with some modifications and fixes. (source code)


GUI Library for Processing by Martin Leopold, mentored by Florian Jennet
GUI Library is a prototype for a new graphical user interface library for Processing.

PDE X by Manindra Moharana, mentored by Daniel Shiffman
PDE X is a Processing mode that augments the development environment with new features such as code completion, refactoring, real-time error checking, and debugging. This is a continuation of Manindra’s 2012 GSOC work and shows some future possibilities for the PDE.

Serial Library for Processing by Gottfried Haider, mentored by Casey Reas
Serial Library replaces Processing’s existing RXTX-based serial library with one built on top of Java Simple Serial Connector. The core API remains the same, but this under-the-hood work allows Processing to better support all platforms.

Tweak Mode by Gal Sasson, mentored by Daniel Shiffman
Tweak Mode is a Processing mode that allows “tweaking” of hard-coded numbers in a sketch’s code through a user interface. The user can tweak the values while the sketch is running and the sketch window updates in real-tim


Debugging Tool for the Processing Development Environment by Martin Leopold

Sketch Assistant by Manindra Moharana

Streamlining Bluetooth Connectivity in Processing for Android by Joshua Albers


Eclipse Replacement For Processing Development Environment (PDE) With Localization by Harshani Nawarathna

Dynamic Library and Tool Loading by Peter Kalauskas

Original Reports

GSoC 2015
GSoC 2014
GSoC 2013