Search processing.org:

###

Where's the old FAQ!?!
When can I download Processing and how much does it cost?
How do I get started?
How do I learn to use Processing?
On which platforms does Processing run?
Is Processing open source?
Do I have to cite Processing or share my code? Can I distribute my sketches?
What's with the version numbers?
Why is it called “Processing”?
What is the sketchbook? What do you mean by sketches?
Why Java? Or why such a Java-esque programming language?
Dude, Where's the Timeline? This Sucks… / Awesome! A Flash Killer!
I know Java, is this Java? How do I use it that way?
Where does this project come from? Is this DBN?
Why Is Processing Connecting to the Network?
What is that fantastic typeface used for the page headers?

##### Where's the old FAQ!?!

The former multi-page FAQ grew too large, and for release 0116, it has been dispersed throughout the reference. The troubleshooting page is perhaps the most important, it contains most of the former bugs.html, which had outgrown its title. The sections relating to library issues (video, OpenGL, serial) have moved to the web pages for those libraries. Changes between releases has its own page, as do the sections that cover specific platforms and the how and why of exporting your code.

##### When can I download Processing and how much does it cost?

The software is free to download. If you are interested in testing the BETA version of the software, visit the download page and follow the instructions.

We think it's important to have Processing freely available, rather than selling it for a million dollars under some godawful yearly contract update scheme. To that end, we encourage people to spread the word and refer them to the processing.org site.

##### How do I get started?

Double click the 'Processing' application, and select something from the examples menu: File → Open → Examples. Hit the 'run' button (which looks like the play button on a vcr or tape deck). Lather, rinse, repeat as necessary.

More information on using Processing itself is can be found in the environment section of the reference.

If you're having trouble getting Processing to start, check the troubleshooting section of the reference for possible solutions.

##### How do I learn to use Processing?

To learn the Processing language, we recommend you try a few of the built-in examples, and check out the reference.

When using the examples (or trying someone else's code), if you run across a function that you're not familiar with, highlight the word, right-click (ctrl-click on the mac), and select "Find in Reference" to open the reference page for that keyword. This can be helpful for understanding how programs work.

If you're stuck or want to talk about your work, head over to the discourse section of the site to find open minds and helpful peers.

Once you've graduated beyond the examples and devoured the "complete" reference, also check out the Processing Hacks site: it's not quite reference, not quite examples, and not as developed as a library. These mutants are known as hacks, and there's lots of good stuff to be found.

##### On what platforms can I run Processing?

We release versions for Windows, Mac OS X, and Linux. We test extensively on Mac and Windows platforms, but not much on Linux.

More detailed information for the specific platforms can be found in the Platforms section, which also includes information about running the Processing Development Environment on other platforms.

##### Is Processing Open Source?

The Processing development environment is released as open source under the GPL. The export libraries (also known as 'core') are released under an LGPL license, which means they can be used as a library and included in your project without you having to open up your code (though we encourage people to share anyway). But if you make changes to core, you have to submit back to us. More information about the GNU Public License can be found at www.gnu.org/copyleft/gpl.html.

Processing also relies on other open projects, namely:

- the older ORO Matcher, distributed under a BSD-style license as part of the Apache Jakarta project
- the Jikes compiler, which is covered by the IBM Public License.
- the jEdit Syntax package, which is public domain
- com.ice.jni.registry from the Giant Java Tree (GPL license)
- perhaps others, but that's all I can think of right now while we're cramming for the beta release

The source code is stored on our developer site, and more information about its use can be found over there.

The source code for the libraries is also included with the Processing software itself, should you want to modify them for your own use. If you want to modify the library for your own use, you can include the .java file as part of your sketch. Just be sure to remove the "package processing.xx;" line at the beginning. The Processing environment does not allow packages.

We need help! Having shared all the code and made it available for free, doesn't it just make you want to pitch in? We have too much work to do and can't keep up with things. We love to see bug fixes, new libraries, etc. If you're interested, contact us via the discourse section of the site.

##### Do I have to cite Processing? Do I have to share my code? Can I distribute my sketches?

We like it when people include a "Built with Processing" note with a link back to the site, since it helps create interest and brings in more people to the project. We don't/can't/shouldn't require it, but it makes us happy because the project is free and this is one way you can help give back to us.

You can also remove the source code from web pages that you export, but in the spirit of the Processing project overall, we include it by default so as to encourage sharing and learning from one another.

You can distribute your sketches all you want, and commercial projects should be just fine too, however we place no warranty on the software (see the download page for the license shenanigans).

##### What's with the version numbers?

This is not 1.0 software.. It's buggy and may kill people.* That's part of why we used to make everyone sign up to download, so that we know that you care enough to bother and have more of an inkling of what you're getting into.

At least until the final 1.0 version, we'll be using four digit numbers for the release. Revision 0085 was the first "beta" release, which means that all the features are in, but not all the bugs are out. There remain several known issues with the beta release that will need to be sorted out before we're comfortable calling a release an actual final 1.0.

The numbered releases aren't always heavily tested, so don't be surprised if/when something breaks. Check the bugs section of the site and report the problem if it's new, and in the meantime, you can go back to the previous numbered release until there's a fix.

* please note that Processing is not yet known to be responsible for any actual deaths

##### Why is it called “Processing”?

At their core, computers are processing machines. They modify, move, and combine symbols at a low level to construct higher level representations. Our software allows people to control these actions and representations through writing their own programs. The project also focuses on the “process” of creation rather than end results. The design of the software supports and encourages sketching and the website presents fragments of projects and exposes the concepts behind finished software.

“Proce55ing” is the spelling we originally used for the URL of the web site, because "Processing" was already taken. Even though it's a combination of numbers and letters, it was always pronounced “processing.” Since then, we saved our pennies, had a can drive, and used the funds to acquire the processing.org domain name. As a result we are no longer using the name “Proce55ing.”

When we see it with the 55's it annoys us and we want to punch people in the face. Or punch ourselves in the face for using it in the first place. Actually, we try not to be that emotional about it but we're trying to avoid the previous naming. However, to make it more confusing, we sometimes still use “p5” (but not p55!) as a shortened version of the name.

##### What is the sketchbook? What do you mean by sketches?

We think most “integrated development environments” (Microsoft Visual Studio, Codewarrior, Eclipse, etc.) tend to be overkill for the type of audience we're targeting with Processing. For this reason, we've introduced the 'sketchbook' which is a more lightweight way to organize projects. As trained designers, we'd like the process of coding to be a lot more like sketching. The sketchbook setup, and the idea of just sitting down and writing code (without having to write two pages to set up a graphics context, thread, etc) is a small step towards that goal.

The idea of just writing a short piece of code that runs very easily (via a little run button) is a direct descendant of John Maeda's work in Design By Numbers, and our experiences maintaining it. (Yes, other languages and environments have done this first, but in our case, the concept is drawn from DBN).

##### Why Java? Or why such a Java-esque programming language?

We didn't set out to make the ultimate language for visual programming, we set out to make something that was:

1. a sketchbook for our own work, simplifying the majority of tasks that we undertake,
2. a teaching environment for that kind of process, and
3. a point of transition to more complicated or difficult languages like full-blown Java or C++ (a gateway drug to more geekier and more difficult things)

At the intersection of these points is a tradeoff between speed and simplicity of use. i.e. if we didn't care about speed, Python, Ruby or many other scripting languages would make far more sense (especially for the simplicity and education aspect of it). If we didn't care about transition to more advanced languages, we'd get rid of the crummy C-style (well, algol, really) syntax. etc etc.

Java makes a nice starting point for a sketching language because it's far more forgiving than C++ and also allows users to export sketches for distribution via the web.

Processing is not intended as the ultimate environment/language (in fact, the language is just Java, but with a new graphics and utility API along with some simplifications). Fundamentally, Processing just assembles our experience in building things, and trying to simplifies the parts that we felt should be easier.

##### Dude, Where's the Timeline? This Sucks… / Awesome! A Flash Killer!

We're not targeting the same audience Flash. If we wanted to make a Flash killer, we'd have set out to do that and our stated purpose would have been more specific (and we'd have more on the site about "Processing vs. Flash" in the competitive shootout sense... right now we just have information about how the syntax differs so that people can make the transition).

We could have saved a lot of time if we just wanted to build a better Flash. And in the end, as two people, do you really think we can or should bother competing with a company as large as Macromedia? Macrodobe? Does anyone really want a better Flash?

There are things that are always going to be better in Flash, and other types of work that will always be better in Processing. But fundamentally (and this cannot be emphasized enough), there is no all-or-nothing game… We're talking about tools. Do people refuse to use pencils because pens exist? No, you just use them for different things, and for specific reasons. If Processing works for you, then use it. If not, don't. It's easy! It's free! You're not being forced to do anything.

As we have heard, Flash 8 will be better at doing some of the pixel editing/image stuff you can do in Processing, but there are still lots of things we're covering that's not focused on moving pixels (OpenGL acceleration, easy serial port access, video input) and other things that are incomplete in beta but just around the corner ("Export to Application" and more).

##### I know Java, is this Java? How do I use it that way?

Processing code is converted to straight Java code (using the "preprocessor") when you hit the Run button. This also makes it possible to embed other Java code in your sketches, or use the core.jar file from the Processing distribution to develop your own sketches with other environments. For instance, if you want to use Eclipse, there are instructions on the discourse section of the site.

The main rule when using Java code: You cannot use anything from the AWT or Swing (which is built on the AWT), because it will interfere with our graphics model If you want to add scroll bars and buttons to your projects, you should make them using Processing code, or embed your Processing applet inside another Swing or AWT application (see below). Even if they appear to work, such sketches are likely to break when you try to run on other operating systems or other versions of Java.

Another point to note when using Java code is that we only support Java 1.4 and earlier. You cannot currently use 1.5 syntax in the Processing Development Environment. This means no generics, templates, enums, varargs, foreach, and the rest. If you want to use Java 1.5 (or later), take core.jar and develop your project with another Java IDE (again, see below). More about Java 1.5 and the rationale for why we don't support it can be found here. A couple of these features are very useful (the for loop, some aspects of generics) so if you would like to help get things running with 1.5 syntax, please see this bug.

Since we can't really support anything and everything that you might want to do when interfacing with Java or using core.jar inside a Java environment, we have a separate discussion area on the discourse board for asking questions about it. This is mostly a peer supported area.

If you want to embed Processing into another Java application, visit the developer's reference for PApplet. A discussion of how to use Processing with Eclipse is found here.

Also note that when using Processing outside the development environment, the headaches of the Java CLASSPATH and PATH return, and using libraries gets much nastier. These issues are just one of the ugly things that we try to hide in the Processing environment, things that separate Processing from straight Java coding. We feel that it is important to put the good stuff at the surface, and that those details don't teach students much anyway (and they annoy advanced users too).

##### Where does this project come from? Is this DBN?

Processing is a descendant of the Design By Numbers (DBN) project. DBN is a simplified programming language that was developed to teach the structure and interpretation of software in a visual manner. Design By Numbers was created by John Maeda and accompanied a book of the same name. While at the ACG, Ben and Casey were involved in the development and maintenance of the DBN softare and courseware, and that experience provided the basis for the Processing project.

While working on DBN, Ben developed several experimental versions that included other programming languages (Python and Scheme) and drawing features (color, changing the window size, magnification, movie recording, and even OpenGL support), but it was clear that these did not make sense for the DBN project because they interfered with Maeda's intention of a simplified programming language and environment.

At the time (between 1998-2000), work at the ACG was usually developed via sketches written in Java and later moved to applications written in C++ using OpenGL. We were interested in melding the idea of "sketching" in code with the pedagogical aspect of DBN. Development of Processing began formally in the Spring of 2001 with discussions between Casey and Ben about API and feature set, and the first version of Processing would be used in August 2001 for a workshop at Musashino Art University in Japan.

##### Why Is Processing Connecting to the Network?

After you double-click Processing, it will check the site for updates. This is helpful so that we can keep people aware of the frequent updates to Processing.

In so doing, it also sends a random number that identifies yours as a unique machine (but sends no personal information to us). This really helps us get a general idea of how many people are using the software, which is really important for things like writing grants so that we can keep Processing free.

If the network connection causes you trouble, it can be shut off inside the Preferences window.

##### What is that fantastic typeface used for the page headers?

The typeface “PS” was developed specifically for Processing by Mike Cina of WeWorkForThem. Other typefaces designed by Mike are available at YouWorkForThem.