Project List

This page documents a list of projects and how you can help contribute to the project.

For all projects, it's incredibly important that things are kept as simple and user-friendly as possible. The PDE is not for developers, it's for people who are less familiar with code, and/or just want to get things done. We're far less interested in features to make the environment more powerful for advanced users than we are in features that make it easier to handle tasks that are common for a wide range of our audience.

In addition to this list, we are also tracking specific bugs and enhancements for Processing in the github issues list. In particular, you might take a look through all of the issues tagged enhancement.

Smaller, Isolated Projects and Fixes

In the push for 2.0, there are a number of smaller projects that could be handled by someone who doesn't necessarily want to dive all the way in to the code. These are isolated things that I've just never had the time to get around to. Any help is appreciated!

Most Important

• The Auto Format needs some love. A motivated person with a couple free hours could take care of a number of issues, including: placement of else statements, extra indents, switch blocks, better maintenance of cursor position, and being able to select a portion of code to be formatted. Someday we'll replace the entire editor, and with it, the formatter, but for now these simple fixes would be huge.
• The serial library needs a friend, especially when it comes to 32- and 64-bit versions for each of the platforms. We also have scattered reports of the library being broken in various configurations (issue 91, issue 357, issue 1374), but this varies across Windows, Linux, and OS X. Someone to babysit these issues and track them down would be most appreciated. We don't currently have a 64-bit version of the library (issue 1275), which is a matter of building the software for the right platforms, and being around to debug it if things go wrong when that's release with the Processing download. (We've added contributed versions in the past, but they were too buggy and we had to revert to the old version since no maintainer was available.)
• Implement blendMode() for the default (2D) renderer on the desktop (issue 1423) and on Android (issue 1424). The modes that are available have been implemented already for the OpenGL renderer on both platforms. See the report for issue 1423 for more information and pointers to sample code to get you started.
• Undo is not behaving properly (issue 707). Also related is how sketches are being set modified: sometimes too aggressively, because some key events are coming through as text being typed when they're just modifiers like the alt key. Oh the embarrassment.
• We've encountered some difficulty supporting all the OS features for Apple retina displays. We could use some help in tracking problems realted tetina displays and providing fixes.

Other Quickies

• A quick change to clipboard handling so that HTML text can be pasted with “Copy as HTML” for HTML-aware applications (like the forum). This is a very easy one—just requires a little work and some testing.
• Prepare a Debian package for the project. Issue 114 covers the attempts so far.
• Look into Windows file association problems and track down what hooks we need to implement in Java so that we can use multiple icon sizes for Windows 7 and friends.
• Wrap Jonathan Feinberg's awesome Python version of Processing as a proper mode so that it can be run from inside the PDE instead of just the command line.
• Implement selectInput(), selectOutput(), selectFolder() on Android (issue 1151).
• Implement a command line version of the Android and/or JavaScript modes. In 2.0 beta 4, we've added a command line support for Java mode, but it'd be great to have the others as well.

Everything Else

This section has been updated in conjunction with our organization application for Google's 2013 Summer of Code. Get in touch if you have questions.

Processing Development Environment (PDE)

• Tool Chest: We've build a system that allows the PDE to be extended to enhance the action of programming. There's an extensive list of potential tools on the Processing Wiki that are waiting to be programmed. Instructions for building tools are here on the GitHub wiki.
• Internationalization and localization: We need to do the i18n and l10n work for Processing and its GUI. We need something very, very simple on the i18n side so that it's easy to deal with in code, and easy for people to add new languages. Not terribly difficult work, but just needs to be handled in a way that doesn't change every instance of text in the source code into five lines of confusing mess.

Processing for Android

• Additional Libraries to extend support to mobile device APIs for networking, mapping, and reading sensor data. We'd like to start with simple examples for different features (as we've done in the most recent release), and as these are ironed out, make them into libraries. We are not looking for a monolithic library to support all types of sensors, but lots of small examples of how to use different features. These libraries are not intended to be comprehensive, but rather focus on simple ways of using devices.
• Interface/back-end: In release 0194, the run/stop/cancel interface took a step backwards, as changes were made to get things working under the new 'mode' system. This needs some care. It involves staring at some difficult multi-threaded code that handles the build and run cycle, launching an emulator, making sure that an AVD is setup and installed, and so on. In addition, on Windows in particular, we aren't getting very helpful errors out of the ant build scripts. Some tinkering should improve the situation. All this is very important for Android development.

JavaScript Mode

• Because Processing libraries (core and contributed) are written in Java, they are not available in JavaScript mode. We are looking for help in creating a template for writing "cross-mode" libraries as well as implementing some of our core libraries in JavaScript (namely video, which has been started here).

Libraries

• Is there something you think Processing should do, but it currently doesn't? Processing can be extended through libraries and we're always looking for contributions. Instructions for building libraries are here on the GitHub wiki.
• Someday, somewhere, Processing might include classes for user interface elements as a core library. We're on the lookout for contributions in this direction and are thinking about ways that Java GUI elements could mix with JavaScript ones.

Video

• Thanks to an enormous effort by Andres Colubri, the video library for Processing 2.0 has a new engine built on top of GStreamer. The library is complete for 2.0 but there is always room for improvement. We could use help with updating the gstreamer binaries bundled with the video library to the 1.0 version. The ones currently in use correspond to the 0.10 series, which is not longer maintained. We'd also like to support for as many capture devices as possible and investigate ways of improving playback to allow for smoother scrubbing of a video.

Bugs

• Bug Exterminator: The software always has Issues (as documented on the Google Code site) to be dealt with.
• Bug Evaluator: Our forum tends to fill up with reports of actual bugs, while the issues database fills with nitpicks that aren't really bugs. Someone to deal with these things and assess the real situation would be huge.

Projects in Progress

This section tracks projects that are undergoing development by members of the Processing community as well as students from Google Summer of Code 2012. While these projects have active interest and dedicated developers, please feel free to get in touch if you'd like to help out.

PDE

• Improving the debugger: Ben has never had the time to work on a proper debugger for the PDE, which means... we don't have one! If you're interested in working on this, this is the JDK documentation section that's relevant. We only use the JDI for launching a Java VM, which we only use to control starting, stopping, and getting exceptions. I've never had time to look into stepping through programs or being able to look at variables and their state (much less threads or others), but obviously folks would be interested in this. Though we only use JDI, there are parts of the JVM Tools Interface (JVM TI) that might also help. There were additional features added to JPDA in Java 6 that we haven't made use of in the past, but Processing 2.x will require Java 6, so those features can be used (though Java 7 or later features cannot). The source you'd be looking for is inside: processing/app/src/processing/mode/java and in particular processing/app/src/processing/mode/java/runner/Runner.java. Our Google Summer of Code projects from 2012 have given us major improvements here! Stand by for updates.

Video

• While there are many contributed libraries for computer vision (including a few for OpenCV), we would like to investigate the feasibility of a better-supported OpenCV library to give Processing built-in features such as face detection, blob detection, etc. At the moment, getting OpenCV to work is a tricky proposition due to cross-platform differences, build instructions, and 32- vs 64-bit problems. It should be possible to make a single library that covers OpenCV and a simple Processing layer to it, but that can be contained in a single library (requiring no additional installation steps), the way we've done with gstreamer. This is now under development and we are currently investigating the pros and cons of using JavaCV vs the new OpenCV desktop bindings for Java.