The Processing Development Environment (PDE) is currently tested on:
- Mac OS X 10.8
- Windows XP (latest service pack only)
- Windows 7 (32-bit and 64-bit)
- Ubuntu Linux 10.04 (32-bit)
- Ubuntu Linux 12.04 (64-bit)
These are the operating systems that are on machines at the Processing Release Testing And Quality Assurance Center (the PRTAQAC, which bears a suspicious resemblance to Ben's apartment).
At the moment, OS X 10.8 gets the most testing because that's what's used for development. If you run into trouble, you've gotta let us know, the PRTAQAC is badly understaffed.
Also check out the Troubleshooting page for platform-specific issues.
Windows is generally the the best platform for running Java applications. It's not because we like Windows (we don't) but that's just how it is.
We are not supporting or testing with Windows Vista. We're going straight from Windows XP to Windows 7.
Testing with Windows 8 has not started.
The 32-bit version of Processing is recommended on Windows.
It's not possible to use Processing with Windows 98, ME, or 2000. Recent Server editions are not supported, though they should work.
Mac OS X
Java on Mac OS X has always dragged behind other platforms.
- As of Processing 2.0, OS X 10.8 receives the most testing. If you're using an earlier version, you should consider upgrading because even Apple is aggressively dropping support for earlier versions.
- Mac OS X 10.7.3 or later is required to run Processing. Mac OS X 10.8 is recommended. A 64-bit machine is also necessary.
- It looks like OS X 10.9 will be released October 22, so support for 10.7 may end sometime soon. Mac OS X 10.9 has had only minimal testing and is not supported.
- With Processing 2.1 (and current source code), all support for 10.6 has been removed.
- Also starting with Processing 2.1, we are no longer using Apple's (deprecated) version of Java and have switched to the Oracle release. This means:
- Processing is only 64-bit on OS X, because Oracle's Java only supports 64-bit machines.
- There will be bumps in the transition. Help me fix them.
- The earliest version of Oracle's Java that works is 7u40.
- The download size is larger, because an entire JRE has to be embedded.
- The key conventions in OS X are closer to other programmer's editors on OS X (TextWrangler, Eclipse, etc). This makes some people unhappy. Those people can manually edit preferences.txt (its location is listed in the Preferences window) to change a line or two:
# The home and end keys should only travel to the start/end of the current line. # The OS X HI Guidelines say that home/end are relative to the document. # if this is not to your liking, this is the preference to change: editor.keys.home_and_end_travel_far = false # The home and end keys move to the first/last non-whitespace character, # and move to the actual start/end when pressed a second time. # Note that this only works if editor.keys.home_and_end_travel_far is false. editor.keys.home_and_end_travel_smart = true
For the 2.0b8 release, some initial work has been done to support Apple's “Retina” displays. This is not ready for prime time (it should be considered "alpha" quality or worse), but please help test it (and file issues on Github) so that it's ready for the final 2.0 release. While this code will be in 2.0b8, please test by using the source from Github because this is an area undergoing active development. To be clear, Retina support is not available/usable in 2.0b7 or earlier. Even once 2.0b8 is available, please use the source from Git for testing.
To make use of the retina-enabled renderer, use the following on an OS X machine with a retina display:
size(960, 540, "processing.core.PGraphicsRetina2D");
Generally, this should give you nice 2D graphics (smoother type, sharper images if large versions are loaded). If you find quirks, please file an issue on Github.
The goal for the retina version is that everything runs unchanged, but this also means that pixel-related operations will produce ugly results, because they use "low" resolution pixels. This is a list of pixel operations:
- get() and set()
- loadPixels(), updatePixels()
- saveFrame() (and save() in some circumstances)
- copy() and blend()
To improve rendering quality with pixel operations, use:
inside your setup() method. This indicates to Processing "I understand this is a retina display, and that all pixel operations will be 2x the size". This will cause pixel operations to instead work in a "doubled" coordinate space. For the 960x540 example used above, that means that calling loadPixels() will produce a pixels array that's 1920x1080 pixels. Or that get(0, 0, 960, 540) will only return the upper left quarter of the sketch image. But saveFrame() will also give you nice, accurate 1920x1080 images instead of the "fuzzy" 960x540 version that you get without the hint().
This needs a lot of testing, so please help. There may be many bugs.
The long size() command used above is just because this feature is in testing. For the final release, Processing will automatically detect retina support and choose the correct renderer. (It doesn't now because it's not been tested enough, and we don't want to break something major.)
There is no OpenGL support, and we have no idea if/when that will happen. It will depend on the progress of the JOGL and LWJGL projects.
With any luck, the Linux release should work fine by simply changing to the processing folder and typing
On Linux, the Processing application is just a shell script. If you set up a launcher (e.g. in Ubuntu), be sure to set the working directory to the folder that contains the shell script. It's not smart enough to find its own path. (If you can write a version that's smarter, please let us know).
Most problems on Linux come from the version of Java that's included in the download being incompatible with the OS. In that case, remove (or rename) the included ‘java’ folder, and replace it with a usable version of the JRE 7. You can also symlink it to a JRE that's installed on your machine. Be sure that the symlink is set up relative to the ‘processing’ shell script such that ./java/bin/java points to the ‘java’ binary. Take a look at the folder structure of the included ‘java’ folder to see how it works.
If you replace the 'java' folder, you'll lose the default fonts used for the PDE. You can get them back by copying the “SourceCode” items from the included java/lib/fonts folder to your new java/lib/fonts.
Due to incompatibilities, OpenJDK is not supported. You'll need a regular Java release downloaded from Sun/Oracle. The GNU Classpath, GCJ, GIJ combination will not work with Processing. OpenJDK and IcedTea also have problems, particularly with running sketches full screen or with multiple displays or even window sizing. Bottom line: use the version from Oracle.
If you get Processing to run properly, the Sketch → Show Sketch Folder command may not be available. Processing will attempt to find kde-open and gnome-open, and if neither is available, the menu item will be dimmed. To fix this, you must set a launcher for your platform. Add a line to ~/.processing/preferences.txt that specifies its location:
launcher.linux = /path/to/launcher_app
Because Processing is written in Java, it should run on any platform that supports Java 1.6. If you'd like to get it running on BSD, Irix, AmigaOS, BeOS... whatever, do the following:
- Download the Linux version, and replace the “java” folder with versions that support your platform. (See the Linux instructions about linking to a proper JDK).
- Next, mess with the shell script if necessary to get things up and running.
- If you have success, share the details for others.
Processing is designed (and supported) to run on Oracle Java. While people have had various degrees of success with running it on ARM based devices like the Raspberry Pi(ARM 11) using open-jdk, etc, there's no official support for it yet. Also, using an alternative to Oracle Java may limit some Processing features.
Users of OpenBSD can use the ports and packages framework to install Processing using the following command:
Please note this package is not created by the Processing team and any possible issues should initially be reported to the package maintainer.
Starting with Processing 2.1 (and the source code as of October 2013), we're moving to Java 7u40 from Oracle on all platforms. Going forward, this is the minimum required version.
Across all platforms, Processing uses an embedded version of Java 7u40, so no additional installation is necessary.
Note that the preprocessor does not support Java 7 language/syntax features, and there are no plans to implement them. Care to contribute?
Users should never have to install Java, because it's embedded with Processing itself. Reinstalling Java will generally be a useless exercise, unless you've messed with the files and folders in the Processing download.