Skip to content
This repository

Write Processing sketches in Python

branch: master
Octocat-spinner-32 .settings Sanitize formatter settings. April 16, 2014
Octocat-spinner-32 JREs New ant build process, with JRE auto-download. July 06, 2013
Octocat-spinner-32 buildtime Replace java boolean ops with python in pde2py. April 15, 2014
Octocat-spinner-32 examples.py Fix Toroid example. December 02, 2013
Octocat-spinner-32 libraries Include Peasycam library. September 01, 2013
Octocat-spinner-32 misc Sanitize formatter settings. April 16, 2014
Octocat-spinner-32 mode Ported Demos/Graphics/Yellowtail to Python for Golan. April 16, 2014
Octocat-spinner-32 processing-py.app New ant build process, with JRE auto-download. July 06, 2013
Octocat-spinner-32 runtime Simple interning of PyIntegers for wrapping PApplet magic variables. April 16, 2014
Octocat-spinner-32 testing Implement "Import Library..." April 04, 2014
Octocat-spinner-32 workspace Updated example, added redirection support. March 31, 2013
Octocat-spinner-32 .classpath Enough of the mode is hooked up to press the run button. April 02, 2014
Octocat-spinner-32 .fatjar initial import July 19, 2010
Octocat-spinner-32 .gitignore Clean up the build. April 15, 2014
Octocat-spinner-32 .project Restored Eclipse files. February 16, 2013
Octocat-spinner-32 .pydevproject Use real flags in pde2py January 25, 2014
Octocat-spinner-32 HOWTO-HACK.txt Create HOWTO-HACK.txt. March 31, 2014
Octocat-spinner-32 LICENSE.txt add license August 12, 2010
Octocat-spinner-32 README.markdown Updated list of platforms Processing.py is known to run on. October 28, 2013
Octocat-spinner-32 build.xml Clean up the build. April 15, 2014
Octocat-spinner-32 processing-py-test-suite.launch Simplify end-of-sketch lifecycle handling by overriding exitActual() April 01, 2014
Octocat-spinner-32 processing-py.bat Fixed Windows .bat local Java lookup. October 28, 2013
Octocat-spinner-32 processing-py.sh New ant build process, with JRE auto-download. July 06, 2013
Octocat-spinner-32 pushbuild.sh Tweak utility scripts. April 11, 2014
Octocat-spinner-32 testmode.sh Add LowLevelGL example to PythonMode. Fix bugs found while doing so. April 15, 2014
README.markdown

processing.py

Write real Processing sketches in Python.

Tested on Mac OS 10.8 & 10.9, Windows XP, 7 & 8, and Ubuntu 12.10.

Quick Start

Download Processing.py 0202

Then, paste this code into a file, e.g., mysketch.py.

def setup():
    size(600, 400)

def draw():
    ellipse(mouseX, mouseY, 10, 10)

Drag and drop your sketch onto one of these files, according to your platform:

You can also run the sketch from the command line, either with the included launcher script:

$ ./processing-py.sh path/to/mysketch.py

or using your own Java runtime environment:

$ java -jar processing-py.jar path/to/mysketch.py

Documentation

To learn Processing.py check out these resources:

Processing.py comes with many examples, most of which are exactly like the example sketches that come with Processing, but converted to Python.

$ processing-py.sh examples.py/Basics/Math/noisefield.py
$ processing-py.sh examples.py/Library/OpenGL/SpaceJunk.py
$ processing-py.sh examples.py/3D/Typography/KineticType.py
$ processing-py.sh examples.py/3D/Textures/TextureCube.py

Using Processing Libraries

Processing.py is implemented in Java, and is designed to be compatible with the existing ecosystem of Processing libraries.

  • Put processing extension libraries in the libraries subdirectory of your processing.py installation. Processing.py will search every jar file and directory beneath that special directory, so you don't need to be too fussy about where things go. Just unzip Processing libraries right there.

  • Import the library in one of the usual Python ways, as in these snippets:

    from peasy import PeasyCam
    # or
    import peasy.PeasyCam
    # or
    import peasy.PeasyCam as PeasyCam
    

    Unfortunately, from foo import * is not supported.

  • Then, in your setup() method:

    cam = PeasyCam(this, 200)
    

    Many libraries need a reference to "the current PApplet", and that's what this is for. Of course, there's no such thing as this in Python; it's just something that processing.py provides for you for compatibility with such libraries.

Included Libraries

Some Processing libraries may not work with processing.py right out of the box. In particular, any library that uses Java reflection to call specially-named functions in your sketch will not work. However, we're happy to modify processing.py to work with any of the official Processing libraries. Here are the libraries that have required special handling in processing.py, and are included in the processing.py download:

If you find that some Processing library doesn't work as expected with processing.py, please let us know in the bug tracker.

FAQ

  • How do I report bugs or request new features?

    Please report any issue in the bug tracker.

  • How can I create a launcher for my sketch?

    Add these lines near the top of your script:

    import launcher
    launcher.create()
    
  • How should I load data?

    [Tentative] Along with the launcher, consider using pwd() for file paths. For a given argument it resolves the path for an object relative to the currently running script:

    data = load(pwd("data.txt"))
    

    In that case, processing.py will try to search data.txt always where your script resides.

  • How can I use Ani, or any other library that modifies fields?

    Some libraries such as Ani require you to specify a variable name for animation. Unfortunately they cannot access Python variables directly (and Java's built in classes are immutable).

    To solve this problem we instead create a mutable PrimitiveFloat object. This object has a field .value, which you can use for these purposes.

    import jycessing.primitives.PrimitiveFloat as Float
    x = Float(100.0)
    Ani.to(x, 200, "value", 50);  # "value" is the name of the Float's internal field
    

    In case you need other primitive values, please let us know!

  • Why was this project created?

    I (Jonathan) recently gave a talk about Processing to a group of rather bright 8th-graders, as part of a computer-programming summer camp they were attending at my office. Their curriculum up to that point had been in Python, which is an eminently sensible choice, given the pedagogical roots of the language.

    The kids were really turned on by the demos--I showed them the white glove, and Golan Levin's New Year's cards--but they were bogged down by Processing's C-like syntax, which really seems arcane and unnecessarily complex when you're used to Python.

    I shared my experience with Processing creators Ben Fry and Casey Reas, and they told me that, indeed, the original Processing was a fork of "Design By Numbers", with Python and Scheme support hacked in. Support for a multi-lingual programming environment was always part of the plan, so they were enthusiastic about any new attempt at the problem.

    I was able to hack up a proof of concept in a couple of hours, and have managed to create something worth sharing in a couple of weeks. I was only able to do it at all thanks to the brilliant and beautiful Jython project.

    At the time of Processing's first public release, August of 2001, Jython was too young a project to be used in this way. But now, having done absolutely no work to profile and optimize, I can get hundreds of frames per second of 3D graphics on my linux box. So, kudos to the Processing project, and kudos to Jython!

Credits

Written by Jonathan Feinberg <jdf@pobox.com> Launcher & many improvements by Ralf Biedert <rb@xr.io>

Also, YourKit, LLC was so kind to sponsor a license for their excellent YourKit Java Profiler. Thank you very much!

Something went wrong with that request. Please try again.