Hubbry Logo
ProcessingProcessingMain
Open search
Processing
Community hub
Processing
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Processing
Processing
Processing
View on Wikipedia
from Wikipedia
Processing
On a light grey background, a stylized letter "P" made out of two rectangles and a semicircular arc in different shades of blue. The simple shapes evoke the way designs are created by the Processing library.
ParadigmObject-oriented
Designed byCasey Reas, Ben Fry
First appeared2001; 24 years ago (2001)
Stable release
4.3.1 / November 12, 2024; 11 months ago (2024-11-12)[1]
LicenseGPL, LGPL
Filename extensions.pde
Websiteprocessing.org

Processing is a free graphics library and integrated development environment (IDE) built for the electronic arts, new media art, and visual design communities with the purpose of teaching non-programmers the fundamentals of computer programming in a visual context.

Processing uses the Java programming language, with additional simplifications such as additional classes and aliased mathematical functions and operations. It also provides a graphical user interface for simplifying the compilation and execution stage.

The Processing language and IDE have been the precursor to other projects including Arduino and Wiring.

History

[edit]

The project was initiated in 2001 by Casey Reas and Ben Fry, both formerly of the Aesthetics and Computation Group at the MIT Media Lab. In 2012, they started the Processing Foundation along with Daniel Shiffman, who joined as a third project lead. Johanna Hedva joined the Foundation in 2014 as Director of Advocacy.[2]

Originally, Processing had used the domain proce55ing.net, because the processing domain was taken; Reas and Fry eventually acquired the domain processing.org and moved the project to it in 2004.[3] While the original name had a combination of letters and numbers, it was always officially referred to as processing, but the abbreviated term p5 is still occasionally used (e.g. in "p5.js") in reference to the old domain name.[4]

In 2012 the Processing Foundation was established and received 501(c)(3) nonprofit status,[5] supporting the community around the tools and ideas that started with the Processing Project. The foundation encourages people around the world to meet annually in local events called Processing Community Day.[6]

Features

[edit]
Processing IDE
Stable release
4.3 / July 26, 2023; 2 years ago (2023-07-26)
Repository
Written inJava, GLSL, JavaScript
Operating systemCross-platform
TypeIntegrated development environment
Websiteprocessing.org

Processing includes a sketchbook, a minimal alternative to an integrated development environment (IDE) for organizing projects.[7]

Every Processing sketch is actually a subclass of the PApplet Java class (formerly a subclass of Java's built-in Applet) which implements most of the Processing language's features.[8]

When programming in Processing, all additional classes defined will be treated as inner classes when the code is translated into pure Java before compiling.[9] This means that the use of static variables and methods in classes is prohibited unless Processing is explicitly told to code in pure Java mode.

Processing also allows for users to create their own classes within the PApplet sketch. This allows for complex data types that can include any number of arguments and avoids the limitations of solely using standard data types such as: int (integer), char (character), float (real number), and color (RGB, RGBA, hex).

Examples

[edit]

The simplest possible version of a "Hello World" program in Processing is: 

// This prints "Hello World." to the IDE console.
println("Hello World.");

However, due to the more visually oriented nature of Processing, the following code[10] is a better example of the look and feel of the language. 

// Hello mouse.
void setup() {
  size(400, 400);
  stroke(255);
  background(192, 64, 0);
}

void draw() {
  line(150, 25, mouseX, mouseY);
}

Awards

[edit]

In 2005 Reas and Fry won the Golden Nica award from Ars Electronica in its Net Vision category for their work on Processing.[11]

Ben Fry won the 2011 National Design Award given by the Smithsonian Cooper-Hewitt National Design Museum in the category of Interaction Design. The award statement says:

"Drawing on a background in graphic design and computer science, Ben Fry pursues a long-held fascination with visualizing data. As Principal of Fathom Information Design in Boston, Fry develops software, printed works, installations, and books that depict and explain topics from the human genome to baseball salaries to the evolution of text documents. With Casey Reas, he founded the Processing Project, an open-source programming environment for teaching computational design and sketching interactive-media software. It provides artists and designers with accessible means of working with code while encouraging engineers and computer scientists to think about design concepts."[12]

License

[edit]

Processing's core libraries, the code included in exported applications and applets, is licensed under the GNU Lesser General Public License, allowing users to release their original code with a choice of license.

The IDE is licensed under the GNU General Public License.

[edit]

Design By Numbers

[edit]

Processing was based on the original work done on Design By Numbers project at MIT. It shares many of the same ideas and is a direct child of that experiment.

p5.js

[edit]

In 2013, Lauren McCarthy created p5.js, a native JavaScript alternative to Processing.js that has the official support of the Processing Foundation. p5.js gained over 1.5 million users.[13]

Since April 2022, p5.js has been led by Qianqian Ye, an Adjunct Associate Professor of Media Arts at USC.[14]

ml5.js

[edit]

ml5.js is a p5.js library developed by NYU's ITP/IMA with funding and support provided by a Google Education grant.

Daniel Shiffman has made videos demonstrating ml5 and is a notable code contributor.

Processing.js

[edit]

Processing.js is a discontinued JavaScript port that enabled existing Processing Java code to run on web.

It was initially released in 2008 by John Resig. The project was later run through a partnership between the Mozilla Foundation and Seneca College, led by David Humphrey, Al MacDonald, and Corban Brook. Processing.js was kept at parity with Processing up to its API version 2.1 release.

The project was discontinued in December 2018, two years after its active development had stopped.

P5Py

[edit]

p5 is a Python library that provides high level drawing functionality to quickly create simulations and interactive art using Python. It combines the core ideas of Processing — learning to code in a visual context — with Python's readability to make programming more accessible to beginners, educators, and artists.[15]

Processing.py

[edit]

Python Mode for Processing, or Processing.py is a Python interface to the underlying Java toolkit. It was chiefly developed by Jonathan Feinberg starting in 2010, with contributions from James Gilles and Ben Alkov.[16]

py5

[edit]

py5 is a version of Processing for Python 3.8+. It makes the Java Processing jars available to the CPython interpreter using JPype. It can do just about everything Processing can do, except with Python instead of Java code.[17]

Wiring, Arduino, and Fritzing

[edit]

Processing has spawned another project, Wiring, which uses the Processing IDE with a collection of libraries written in the C++ language as a way to teach artists how to program microcontrollers.[18] There are now two separate hardware projects, Wiring and Arduino, using the Wiring environment and language. Fritzing is another software environment of the same sort, which helps designers and artists to document their interactive prototypes and to take the step from physical prototyping to actual product.

Mobile Processing

[edit]

Another spin-off project, now defunct, is Mobile Processing by Francis Li, which allowed software written using the Processing language and environment to run on Java powered mobile devices. Today some of the same functionality is provided by Processing itself.[19]

iProcessing

[edit]

iProcessing was built to help people develop native iPhone applications using the Processing language. It is an integration of the Processing.js library and a Javascript application framework for iPhone.[20]

Spde

[edit]

Spde (Scala Processing Development Environment) replaces Processing's reduced Java syntax and custom preprocessor with the off-the-shelf Scala programming language which also runs on the Java platform and enforces some of the same restrictions such as disallowing static methods, while also allowing more concise code, and supporting functional programming.[21][22][23]

JRubyArt

[edit]

JRubyArt (formerly named ruby-processing) is a wrapper for Processing in the Ruby language, that runs on the Java platform using JRuby.

Quil

[edit]

Quil is an interactive animation library for Clojure and ClojureScript based on Processing.[24][25]

Sketch

[edit]

Sketch is a Common Lisp library highly inspired by Processing.[26]

Media

[edit]

The music video for "House of Cards" by Radiohead was created using Processing combined with data from lidar technology, along with using acrylic glass and mirrors to create scenes in which the image appears distorted, partially disappears, or disintegrate as if being carried by wind.[27] Processing has also been used to create illustrations for publications such as Nature and The New York Times, to output sculptures for gallery exhibitions, to control huge video walls and to knit sweaters.[28]

See also

[edit]

Footnotes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Processing

View on Grokipedia
from Grokipedia
Processing is an open-source programming language and integrated development environment (IDE) designed to facilitate the creation of visually oriented software, particularly for electronic arts, new media, and visual design. Developed by Ben Fry and Casey Reas in 2001 at the MIT Media Lab as a successor to earlier projects like Design By Numbers, it emphasizes simplicity and accessibility to promote software literacy within the visual arts and visual literacy in technology. Originally conceived as a software for programming fundamentals through interactive and , Processing has evolved into a versatile tool used by artists, designers, educators, and students worldwide. Its syntax, inspired by languages like and , allows beginners to quickly prototype ideas with code that generates dynamic visuals, such as shapes, colors, and motion, while supporting more advanced applications through community-contributed libraries for areas like data visualization, , and hardware integration (e.g., with ). The platform runs cross-platform on macOS, Windows, and , and its free availability has made it a staple in art schools, universities, and high schools, where studies have shown it can double student interest in . The Processing Foundation, established in 2012, oversees its ongoing development and fosters a global community of contributors, ensuring the project's emphasis on diversity and open-source principles. Notable applications include interactive installations in major museums, educational curricula, and professional creative coding projects, highlighting its role in bridging art and technology.

Overview

Description

Processing is an open-source programming language and integrated development environment (IDE) designed for electronic arts, new media art, and visual design communities. It functions as a flexible software sketchbook that enables users to create visual and interactive applications through a simplified programming approach. Initiated in 2001 by Casey Reas and Ben Fry, who were graduate students at the MIT Media Lab under John Maeda's Aesthetics and Computation Group, Processing emerged as a tool to bridge programming with creative expression. At its core, Processing is built on the platform, compiling sketches into for execution while providing a streamlined syntax that makes it accessible even without prior Java knowledge. This syntax draws inspiration from languages like and to simplify coding for visual outputs, supporting features such as 2D and 3D graphics rendering, animation through frame-based drawing functions, and interactivity with input devices like the and keyboard. The sketch-based organizes programs into lightweight, modular files—typically called "sketches"—that emphasize and immediate visual feedback, allowing users to focus on artistic experimentation rather than complex setup. Processing primarily targets artists, designers, educators, and programming beginners who seek to produce without requiring deep knowledge of underlying systems or advanced concepts. It is widely used in art schools, universities, high schools, and by professionals in design, , and to foster software and skills. This focus traces back to influences like John Maeda's Design By Numbers project from 1999, which pioneered accessible programming for visual thinkers and informed Processing's emphasis on intuitive, graphics-oriented development.

Purpose and Applications

Processing is designed to lower the barriers for non-programmers entering the field of coding by providing a simple, visual-oriented environment that facilitates the creation of interactive graphics, animations, and prototypes. Its primary goals include promoting software literacy within the and fostering in technology, allowing users—particularly beginners—to experiment with programming concepts through immediate visual feedback rather than abstract syntax. This approach, inspired by accessible languages like and , enables rapid iteration and encourages creative exploration over rigorous practices. Key applications of Processing span , where algorithms produce evolving visual forms; data visualization, transforming complex datasets into intuitive graphics; sound visualization, mapping audio inputs to dynamic displays; and interfaces, often integrated with hardware like to control sensors and actuators in real-time. It serves as an educational tool for teaching programming fundamentals through visual outcomes, making abstract ideas tangible and engaging for students in art, design, and courses. In impact areas, Processing has been employed in museums for interactive exhibits, such as those at the , the (MoMA), and the , where it powers immersive installations that respond to visitor interactions. In academia, it has been integrated into curricula at universities, art schools, and high schools worldwide, with studies showing it doubles student interest in pursuing further courses. Within industry, particularly UI/UX and prototyping, Processing supports quick development of interactive mockups and visualizations, aiding architects, designers, and engineers in conceptualizing user experiences.

History and Development

Origins

Processing originated in spring 2001 when Casey Reas and Ben Fry, graduate students at the MIT Media Lab's Aesthetics and Computation Group, sought to create a programming environment tailored for visual artists and designers. As members of John Maeda's research group, Reas and Fry built upon Maeda's earlier Design By Numbers (DBN) project from 1998, which aimed to make programming accessible to non-technical creatives but was limited by its proprietary nature and basic graphical capabilities. They addressed these constraints by leveraging Java's flexibility while simplifying its syntax and setup, enabling rapid prototyping of visual and interactive works without the complexities of traditional software development. The project emerged as part of Reas and Fry's thesis work at MIT, focusing on bridging with artistic expression to empower users untrained in programming. This initiative reflected a broader motivation to democratize technology, drawing from the Media Lab's legacy in exploratory computing tools like the Workshop founded in 1975. By fall , Processing was sufficiently developed for initial public engagement, with Fry teaching the first at Musashino Art University in . At its core, Processing was founded on principles of simplicity, open-source collaboration, and the integration of and to foster creative experimentation. Reas and Fry emphasized intuitive tools that prioritized immediate visual feedback over verbose code, encouraging a culture of sharing sketches and libraries to build a supportive for learners and practitioners alike. This approach not only lowered barriers for artists engaging with code but also positioned Processing as a catalyst for and design innovation.

Milestones and Releases

Processing's development began with its initial alpha release on August 9, 2001, marking the start of a project initiated by and Ben Fry at the . The first stable version, Processing 1.0, was released on November 24, 2008, after years of beta testing and community feedback, providing a mature IDE and language for visual arts programming. This release solidified Processing as an accessible tool, with subsequent minor updates like 1.5.1 on May 15, 2011 focusing on stability for legacy users. Major version updates introduced significant enhancements. Processing 2.0 launched on June 3, 2013, emphasizing improved through better rendering and syntax support, alongside expanded integration for broader creative applications. Version 3.0 arrived on October 1, 2015, shifting to a modular that facilitated easier extensibility and added native support for platforms like with . Processing 4.0 was finalized on August 9, 2022, incorporating 17 compatibility, a redesigned for modern workflows, and optimizations for cross-platform deployment. The latest stable release, 4.3.1 on November 12, 2024, included bug fixes for core functionality and accessibility improvements such as better integration, followed by 4.4.10 on October 14, 2025, which addressed maintenance issues in the build system. Organizationally, Ben Fry served as the long-term lead developer since the project's inception, guiding its evolution until his resignation from the Processing Foundation in October 2023 due to disagreements over the organization's priorities and use of donation funds for software development. Fry has continued to contribute to the Processing software independently since then. The Processing Foundation, established in , formalized the shift to fully , enabling community-driven development. Since the , contributions via have grown, with the main repository fostering collaborative bug fixes, feature additions, and mode enhancements through pull requests and issues. From 2020 to 2025, developments emphasized steady maintenance over radical changes, with updates to web export tools improving mode compatibility for browser-based sketches. Integration with modern hardware, including , saw refinements in Processing 3 and later for seamless embedded applications. A notable derivative milestone was the launch of p5.js in 2013, a extending Processing's principles to .

Technical Components

Language Features

Processing is a programming language that functions as a simplified subset of , optimized for visual and interactive applications within and fields. Its syntax adopts an imperative style, consisting of straightforward statements to declare variables, perform calculations, and issue drawing commands that render directly to a digital canvas. Central to its structure are predefined functions such as setup(), which runs once at startup to configure initial parameters like canvas size and , and draw(), which executes in a continuous loop to handle updates and animations at a consistent , typically 60 frames per second unless adjusted. This looping mechanism provides real-time visual feedback, distinguishing Processing from static programming environments and facilitating rapid iteration in creative workflows. The language incorporates event-driven paradigms to manage user interactions, featuring built-in handlers like mousePressed() for detecting clicks, mouseMoved() for tracking cursor position via variables such as mouseX and mouseY, keyPressed() for keyboard input, and keyReleased() for release events. Graphics form a core capability, with extensive libraries for 2D primitives including ellipse(x, y, width, height) to draw ovals and rect(x, y, width, height) for rectangles, alongside 3D shapes like box(size) and sphere(radius). Transformation functions such as rotate([angle](/page/Angle)) and translate(x, y) enable spatial manipulations, while color systems support RGB as the default mode and HSB via colorMode(HSB), with utilities like fill(c) and stroke(c) to apply hues, saturation, and brightness values. These elements allow for immediate visual experimentation without complex . Data handling emphasizes simplicity, supporting primitive types (integers, floats, booleans), arrays declared as int[] values = {1, 2, 3};, strings for text manipulation, and PImage objects for loading and processing images with functions like loadImage("filename.jpg"). Basic mathematical operations are accessible through functions such as sin(radians) for trigonometric sine and random(low, high) for generating values within a range, supporting procedural patterns and randomness in visuals. Although sketches typically avoid object-oriented constructs for quick prototyping, Processing fully supports Java's object-oriented features, including class definitions, with extends, and object instantiation using new, enabling modular code organization for larger projects. This blend of imperative sketching and extensible paradigms underscores Processing's role in fostering accessible, frame-rate-driven animations and interactive experiences.

Integrated Development Environment

The Processing Development Environment (PDE) serves as the primary interface for developing sketches in Processing, offering an intuitive layout designed to facilitate of visual and interactive applications. Key interface elements include a tabbed that supports multiple files per sketch for organizing , a message area that highlights syntax errors and feedback in real time, a console section for displaying output from functions such as print() and println(), and a dedicated preview window that launches automatically to render 2D or 3D upon execution. This setup emphasizes simplicity, allowing users to focus on without complex setup. At its core, the PDE integrates essential tools for compilation, , and distribution. The built-in leverages the to process .pde files into when the is activated, ensuring seamless integration with Processing's Java-based mode. Basic features enable setting breakpoints to pause execution and inspect variable states, accessible through the Debug > Enable option. functionalities, invoked via File > Application, generate standalone executables or web-optimized outputs, supporting deployment across platforms without additional configuration. The workflow in the PDE is centered on efficient sketch management and . Sketches are stored in a dedicated folder, initiated by File > New, with tabs allowing easy switching between files like the main .pde and supporting assets. Auto-completion for built-in functions and variables activates via Ctrl+Space (after enabling in Preferences > Editor), streamlining code entry. Integrated reference access, through Help > Reference or in-editor search, provides instant documentation for libraries and commands, while adding resources like images occurs via Sketch > Add File to populate the data subfolder automatically. The editor also offers to support Processing's constructs, aiding readability during development. Updates in Processing version 4.0 and subsequent releases have enhanced the PDE's usability and consistency. A new Theme Selector (Tools > Theme Selector) introduces customizable color schemes, including dark mode, to reduce and align with modern development preferences across Windows, macOS, and installations. Cross-platform support has been refined for better consistency, with native compatibility for and architectures, alongside hundreds of bug fixes for interface stability. Font rendering benefits from updated tools like Create Font (Tools > Create Font) and the createFont() function, which generate vector-based fonts for sharper, more efficient on-screen display in the preview window. Workflow improvements include relaxed sketch folder naming rules, configurable via Preferences, to better accommodate version control systems like .

Modes and Extensibility

Processing offers several programming modes that extend its core -based environment, allowing users to write code in alternative languages while maintaining access to the IDE's visual feedback and tools. The default Mode provides the standard Processing syntax built on , but additional modes can be installed through the Contribution Manager. Python Mode, developed via the Processing.py project, enables sketches using Python syntax and leverages for compatibility with Processing's underpinnings, making it suitable for users preferring Python's readability for prototyping visual ideas. The p5.js Mode integrates support, allowing code written in Processing's style to be exported and run in web browsers via the p5.js library, which translates Processing functions to and rendering. This mode facilitates seamless transition to web-based without altering core logic. Android Mode, another official extension, adapts Processing sketches for mobile development on Android devices, incorporating device-specific features like touch input and sensors while compiling to APK files. These modes are managed through the IDE's "Manage Modes" menu, introduced in Processing 4 for streamlined installation and updates. Extensibility in Processing is primarily achieved through its robust library system, which allows integration of community-contributed code to add functionalities beyond the core and capabilities. Libraries are installed via the IDE's Contribution Manager under "Manage Libraries," which connects to a centralized repository of approved contributions. Notable examples include Minim, an audio library for real-time sound synthesis, analysis, and playback, and ControlP5, which provides customizable components like sliders and buttons for interactive applications. Over 200 official and unofficial libraries exist, spanning categories such as , networking, and ; for instance, GSVideo handles video capture and playback using libraries like or . Users can further extend Processing by developing custom libraries in , which are structured as JAR files with accompanying documentation and examples. These user-defined libraries integrate directly into sketches via import statements and can be shared through the community. The contribution process involves submitting proposals via issues to the Processing Foundation's contributions repository, where maintainers review and add them to the official list for inclusion in the Contribution Manager. An example of such extensibility is the integration of ml5.js for in the p5.js Mode, enabling accessible AI features like image classification and pose detection in browser-based sketches without requiring external servers. From 2020 to 2025, Processing 4 introduced enhancements to mode stability, including better compatibility with 17 and fixes for runtime errors in non-Java modes, ensuring more reliable execution across platforms. Updates also refined the system, with improved download handling and validation scripts to support growing contributions. While core renderers like P3D already leverage for 3D graphics, recent community libraries have expanded capabilities for advanced visual effects, and efforts toward accessibility include better high-DPI rendering and tooltips in the IDE. These developments, detailed in , underscore Processing's ongoing evolution to support diverse creative workflows.

Practical Usage

Basic Examples

Processing provides a straightforward for beginners through simple sketches that leverage its core structure: the setup() function for initialization and the draw() function for continuous rendering at a specified . These functions form the backbone of every Processing program, allowing users to create visual output without complex .

Hello World Example

A quintessential starting point is drawing a basic shape, such as an , to verify the environment is functioning correctly. The following minimal sketch illustrates this:

processing

ellipse(50, 50, 80, 80);

ellipse(50, 50, 80, 80);

When executed in the Processing IDE, this single line produces a centered at coordinates (50, 50) with a of 80 pixels on a default gray background. The setup() and draw() functions are implicitly handled by the IDE for such basic cases, running the code once in setup() to set the and repeatedly in draw() for static output. To understand the structure, consider an expanded version that explicitly clears the background for consistent rendering:

processing

void setup() { size(640, 360); } void draw() { background(255); ellipse(50, 50, 80, 80); }

void setup() { size(640, 360); } void draw() { background(255); ellipse(50, 50, 80, 80); }

Here, setup() establishes a 640 by 360 pixel window, while draw() sets a white background (255 represents full white in RGB values from 0 to 255) and draws the ellipse each frame, preventing artifacts from prior renders. The output is a static white canvas with a black circle in the top-left quadrant. Common pitfalls for beginners include omitting the semicolon at the end of statements, which triggers syntax errors displayed in red in the IDE's message area, or forgetting background() calls, leading to overlapping drawings in looped executions. Running the sketch via Ctrl+R (Cmd+R on macOS) displays the result in a new window; stopping it requires clicking the square stop button or closing the window.

Interactivity Basics

Processing excels in enabling immediate interaction, such as responding to mouse movements, which introduces dynamic behavior without advanced event handling. A fundamental example tracks the position to draw a following shape, demonstrating variables like mouseX and mouseY that automatically update with cursor coordinates relative to the window's top-left origin. Consider this sketch for a color-changing circle:

processing

void setup() { size(480, 120); } void draw() { if (mousePressed) { fill(0); } else { fill(255); } [ellipse](/page/Ellipse)(mouseX, mouseY, 80, 80); }

void setup() { size(480, 120); } void draw() { if (mousePressed) { fill(0); } else { fill(255); } [ellipse](/page/Ellipse)(mouseX, mouseY, 80, 80); }

In setup(), the window size is set to 480 by 120 pixels. The draw() loop, executing approximately 60 times per second by default, checks if the mouse button is pressed using mousePressed; if so, it fills the black (0), otherwise white (255). The ellipse() is then positioned at the current mouseX and mouseY. The result is an interactive that trails the mouse cursor and toggles color on click, providing visual feedback. Beginners often overlook the need for a background() call if persistence is desired (e.g., to trail the path), as omitting it causes shapes to accumulate; adding background(204); at the start of draw() would clear the canvas each frame. Additionally, mouseX and mouseY remain at their last values if the cursor leaves the window, avoiding erratic jumps. For drawing lines based on mouse movement, a simpler variant uses pmouseX and pmouseY to connect previous and current positions:

processing

void setup() { size(640, 360); stroke(255); } void draw() { background(51); line(mouseX, mouseY, pmouseX, pmouseY); }

void setup() { size(640, 360); stroke(255); } void draw() { background(51); line(mouseX, mouseY, pmouseX, pmouseY); }

This sets a dark gray background (51) and white stroke, drawing a short line segment from the prior frame's mouse position to the current one, creating a trail effect when moved quickly. The output simulates freehand drawing, with line thickness controlled by default settings (1 pixel). A frequent error is not initializing stroke() or background(), resulting in invisible or cluttered lines; testing in the IDE reveals these issues promptly.

Animation Introduction

Animation in Processing arises naturally from the draw() loop's repetition, combined with time-based variables like frameCount, which increments each frame starting from 1 after setup(). This enables smooth motion by updating positions or properties incrementally, typically at 60 frames per second unless adjusted via frameRate(). A basic example animates a circle's horizontal position using the sine function for oscillatory movement:

processing

void setup() { size(640, 360); } void draw() { background(255); float x = sin(frameCount * 0.01) * 100 + width / 2; ellipse(x, height / 2, 80, 80); }

void setup() { size(640, 360); } void draw() { background(255); float x = sin(frameCount * 0.01) * 100 + width / 2; ellipse(x, height / 2, 80, 80); }

The setup() creates a standard window, and draw() clears to white before calculating x as the window's center (width / 2) plus a sine wave offset: sin() takes radians derived from frameCount * 0.01 (a slow multiplier for smooth cycling) scaled by 100 pixels for . The ellipse centers vertically at height / 2 and oscillates left-right. The output shows a circle waving sinusoidally across the canvas, completing a full cycle roughly every 628 frames (since 2π radians ≈ 6.28, and 0.01 scaling yields 628 steps). To set a consistent pace, add frameRate(30); in setup() for 30 FPS. Pitfalls include choosing too large a multiplier (e.g., 0.1 causes rapid flickering) or neglecting background(), which leaves a growing trail; beginners should experiment with values in the IDE to observe effects, using println(frameCount); in draw() to monitor timing in the console.

Advanced Applications

Processing has been extensively applied in data visualization to handle and render complex datasets, leveraging built-in functions like loadTable() for CSV files and loadJSONObject() for parsing to create dynamic charts and graphs. For instance, a typical involves loading a containing fields such as species names and population metrics, extracting values with methods like getString() and getInt(), and plotting them as interactive bar charts or scatter plots using Processing's drawing primitives; this approach enables real-time updates based on user input or live data streams. In interactive installations, Processing integrates seamlessly with hardware like to create responsive environments, where sensor data drives visual outputs. A representative is an ultrasonic sensor-based project where captures distance measurements via , mapping them to parameters such as speed and line thickness in a Processing sketch that generates spiraling geometric patterns; user proximity alters the artwork in real time, demonstrating Processing's role in bridging digital visuals with physical interaction. Generative art in Processing often employs advanced techniques like recursion and Perlin noise to produce organic, evolving patterns without explicit user control. An advanced sketch might use recursion to draw self-similar structures, such as branching trees, by defining a function that calls itself with scaled-down parameters until a base case is reached, combined with Perlin noise for natural variation— for example, generating terrain-like forms where noise values, computed as noise(x * 0.01), modulate branch angles or densities to mimic fluid, non-repetitive growth. Notable projects highlight Processing's impact in artistic practice. Jared Tarbell's Substrate (2003) simulates crystal growth on a computational grid using iterative perpendicular line extensions governed by simple rules, structured around loops that spawn and propagate line segments until a density threshold is met, resulting in intricate, city-like emergent structures across resolutions like 900x900 pixels with 350 objects. Similarly, Joshua Davis's works, such as those utilizing his HYPE library for Processing, explore algorithmic image-making through vector-based interactions and dynamic frameworks, enabling early web art experiments with randomized particle systems and layered compositions that evolve based on procedural rules.

Ecosystem

Several software projects have extended Processing's visual programming paradigm to web browsers, other programming languages, and hardware platforms, enabling broader accessibility and integration.

Web and JavaScript Adaptations

p5.js, released in 2013 and led initially by Lauren Lee McCarthy, provides a JavaScript library for creating browser-based interactive sketches inspired by Processing's simplicity, targeting creative coding in web environments without plugins. In 2021, Qianqian Ye and evelyn masso assumed co-leadership of the project, continuing its development under the Processing Foundation. Earlier, Processing.js, introduced in 2010 by John Resig, translated Processing sketches to JavaScript for web execution but was deprecated in 2017 due to native browser support for technologies like Canvas and WebGL.

Python Implementations

Processing.py, launched in 2012 by Jonathan Feinberg, integrates with Python using , allowing sketches to leverage Python's libraries while maintaining Processing's syntax for graphics and interactivity. More recent alternatives include P5Py and py5, both developed as CPython-based ports that avoid Jython's limitations; py5, created by Jim Schmitz in 2020, notably supports Jupyter notebooks for interactive coding and data visualization.

Bindings for Other Languages

Quil, a wrapper developed starting in 2011, ports Processing's to Clojure, enabling approaches to and animations on the . JRubyArt (formerly ruby-processing), initiated by Jeremy Ashkenas in 2009, adapts Processing for via , facilitating rapid prototyping with Ruby's expressive syntax for visual applications. Similarly, Spde, a Scala project from 2009, provides a development environment and library for Processing-style coding in Scala, emphasizing type safety and concurrency in creative projects.

Hardware and Mobile Extensions

Wiring, introduced in 2005 by Hernando Barragan as a precursor to , offered a simplified programming environment for microcontroller-based prototyping that integrated directly with Processing for data visualization and control. Processing supports hardware through Firmata, a protocol established in 2007, which allows desktop sketches to send and receive data from boards without custom firmware. Fritzing, an open-source tool released in 2010, complements Processing by enabling circuit diagramming and prototyping, often used to design hardware interfaces visualized in Processing sketches. For mobile development, Processing supports Android through an official mode since around 2010, and third-party efforts like Processing-iOS enable limited support for , allowing touchscreen-based interactive applications with Processing's core libraries.

Community and Education

The Processing Foundation, established in as a 501(c)(3) non-profit organization, oversees the ongoing development and stewardship of the Processing project, fostering its growth through , fellowships, and support programs. The foundation promotes software literacy in the and in , drawing on a global of tens of thousands of students, artists, designers, researchers, and hobbyists who engage with the platform. This collaborates via dedicated forums on for discussions and troubleshooting, as well as the project's repository, where users submit pull requests to enhance libraries, tools, and core functionality under the open-source model. Contributions from the extend beyond to creative outputs, with users sketches and projects through exhibitions and galleries featured on the official Processing website, showcasing and visualizations. Collaborative events such as hackathons, game jams, and workshops encourage collective experimentation in , often centered on themes of , , and social issues. The annual Processing Community Day, initiated by the foundation, brings together participants worldwide for workshops, lectures, and discussions on computational , with events held in cities like , , , and to promote accessible learning and networking. In education, Processing is integrated into curricula at institutions such as the (RISD) and (NYU), where it supports courses in , , and computational arts, enabling students to prototype ideas through visual programming. Free resources bolster this role, including online tutorials, example sketches available on the Processing site, and textbooks like Learning Processing by , which provides a beginner-friendly introduction to programming concepts through and interaction. From 2020 to 2025, the community has seen increased emphasis on online learning, particularly through p5.js—a JavaScript library derived from Processing—that facilitates web-based education and broadens access for remote learners and educators. As of 2025, updates to libraries like p5.js (reaching version 1.9) continue to enhance the ecosystem. The Processing Foundation has advanced diversity initiatives by investing in programs that expand access to technology and arts communities for underrepresented groups, including fellowships and advocacy for equitable participation in . These efforts underscore sustained engagement, reflected in the platform's role as a foundational tool for teaching across diverse educational settings.

Recognition

Awards

In 2005, Casey Reas and Ben Fry received the Golden Nica in the Net Vision category at the Prix for their development of Processing, recognizing its innovative approach to enabling through programming. That same year, the Processing project also earned the Interactive Design Prize from the Tokyo Type Directors Club, highlighting its impact on and . In 2011, Ben Fry was awarded the National Design Award for Interaction Design by the Cooper Hewitt, Smithsonian Design Museum, for his contributions to data visualization and tools like Processing, which he co-created with Reas. Casey Reas has received further recognition in art-technology fields, including the 2020 Lumen Prize Moving Image Award for his audiovisual work exploring generative processes, building on the foundations of Processing. Established in 2012, the Processing Foundation has provided ongoing grants and fellowships to artists, educators, and technologists, supporting projects that advance creative coding and software literacy within underrepresented communities. These initiatives, such as the annual Processing Fellowships, have funded dozens of multidisciplinary works since inception, fostering innovation in digital arts. These accolades underscore Processing's pivotal role in democratizing access to digital art and programming, bridging technical and creative domains for broader audiences.

Cultural and Media Impact

Processing has significantly influenced generative and movements by providing artists with accessible tools for creating dynamic visual works based on algorithms and real-time interaction. Developed in 2001 by and Ben Fry, it has empowered creators to explore computational , fostering a shift toward software-based practices that blend with visual expression. This influence is evident in major festivals, where Processing sketches have been showcased in art programs, including primers and generative installations that demonstrate its role in computational arts education and exhibition. Similarly, interactive installations at events like have utilized Processing to produce immersive, algorithm-driven experiences in public settings. The language has received notable media coverage that highlights its role in democratizing creative coding. Featured in books like Daniel Shiffman's The Nature of Code (2012, revised 2024), which uses Processing to simulate natural systems and has become a cornerstone for teaching algorithmic design, it underscores the tool's pedagogical impact on digital creativity. Documentaries such as Hello World! Processing (2013) explore its contributions to creative coding, examining how process, experimentation, and algorithms shape artistic output within global communities. Interviews with creators Reas and Fry in Wired magazine, including discussions on Processing as the "lingua franca of creative coding" (2015) and its evolution in version 2.0 (2013), have further amplified its cultural significance in bridging art and technology. Beyond art, Processing has inspired broader applications in data visualization and , with co-creator Ben Fry leveraging it for innovative infographics that inform public discourse on complex datasets. Its integration into promotes hands-on experimentation, while initiatives by the Processing Foundation, such as fellowships emphasizing inclusive STEM toolkits, support underrepresented groups in and by fostering belonging through . In recent years (2020–2025), Processing's adaptability has driven its use in NFT art, where generative sketches on platforms like OpenProcessing enable on-chain creation of unique digital collectibles, aligning with blockchain-based artistic economies. During the , it facilitated virtual exhibitions, allowing artists to develop interactive online installations amid physical closures. Collaborations involving the Processing Foundation, including Casey Reas's involvement in MoMA's 2021 Modern Dream project with —which interpreted the museum's collection via and NFTs—highlight its ongoing role in institutional initiatives.

Licensing and Availability

License Details

Processing's core library, which includes the language libraries essential for visual and interactive programming, is released under the GNU Lesser General Public License version 2.1 (LGPL-2.1). This license allows users to modify and distribute the library freely, link it with without requiring the entire application to be open-sourced, but mandates that any changes to the library itself be made available under the same terms. In contrast, the Processing Development Environment (PDE), , along with other components such as tools and examples, falls under the GNU General Public License version 2 (GPL-2.0). The GPL requires that derivative works based on these components be distributed under the same license, ensuring availability and promoting collaborative development. This setup supports free use, modification, and redistribution, including for commercial purposes, provided the conditions—such as sharing modifications—are met. Additionally, the reference documentation, including comments, is licensed under the Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) , permitting non-commercial and with attribution while requiring derivatives to use the same terms. While the core components adhere to these licenses, some contributed libraries within the Processing ecosystem may operate under alternative open-source licenses, such as the 2.0, allowing for varied compatibility in extensions and integrations. The Processing Foundation maintains oversight to ensure overall compliance and consistency in the project's open-source ethos.

Platforms and Distribution

Processing is distributed as free, , available for directly from the official at processing.org. Installers are provided for major desktop operating systems, including Windows (via .msi or .zip files), macOS (via .dmg files supporting both and architectures), and (via .tar.gz archives or Snap packages for distributions like and ). Portable versions are supported through zip and tar.gz s for Windows and , allowing users to run the IDE without a traditional installation by extracting the archive and launching the executable. The primary supported platform is desktop environments on Windows, macOS, and , where the Processing Development Environment (PDE) runs natively. Sketches created in Processing can be exported to the web using p5.js, a derived from Processing for browser-based execution. For mobile and embedded systems, support is available through related projects such as Processing for Android (enabling APK exports) and modes for , though these require additional setup beyond the core desktop distribution. The IDE bundles 17 for 64-bit systems, ensuring compatibility with 8 and later versions for sketch compilation and execution, while maintaining backward compatibility for older Java features in user code. Installation is streamlined for ease of use, typically involving a one-click : users the appropriate installer, execute it (e.g., running the .msi on Windows or dragging the app to the Applications folder on macOS), and the bundled runtime is automatically included, eliminating the need for separate JDK installation. Updates to the core IDE are handled by ing and installing new releases from the official site or , with the built-in Contribution Manager facilitating updates for libraries, modes, and tools within the IDE. Archives of older versions, such as Processing 4.3 and earlier, are maintained on for users requiring legacy compatibility or specific features. Accessibility features include the IDE's intuitive interface designed for , with available in multiple languages through the Processing and resources, though the PDE interface itself is primarily in English. The Processing Foundation supports ongoing development through voluntary donations, which can be made via their official site to fund maintenance and enhancements. For developers, source code and pre-release builds are hosted on , with the latest stable release being version 4.4.10 from October 2025, enabling custom builds and contributions.

References

  1. https://processing.org/overview/
  2. https://processing.org/download/
  3. https://processing.org/
  4. https://processing.org/tutorials/overview/
  5. https://www.arduino.cc/education/visualization-with-arduino-and-processing
  6. https://medium.com/processing-foundation/a-modern-prometheus-59aed94abe85
  7. https://www.youtube.com/watch?v=F8jwQP7wr6k
  8. https://www.wired.com/2008/11/processing-laun/
  9. https://github.com/processing/processing/blob/master/build/shared/revisions.txt
  10. https://www.wired.com/2013/06/processing-2-0-released/
  11. https://www.wired.com/beyond-the-beyond/2015/10/processing-3-0-released/
  12. https://medium.com/processing-foundation/announcing-the-latest-version-of-processing-processing-4-3a1f8b8a7aed
  13. https://medium.com/processing-foundation/announcing-the-release-of-processing-4-3-1-eef3b25fa377
  14. https://processing.org/releases/
  15. https://discourse.processing.org/t/ben-fry-resigning-from-the-processing-foundation/42888
  16. https://github.com/processing/processing4
  17. https://github.com/processing/processing4/releases
  18. https://forums.raspberrypi.com/viewtopic.php?t=118187
  19. https://processing.org/reference/setup_.html
  20. https://processing.org/reference/draw_.html
  21. https://processing.org/reference/ellipse_.html
  22. https://processing.org/reference/
  23. https://processing.org/tutorials/objects/
  24. https://processing.org/environment/
  25. https://github.com/processing/processing4/wiki/Changes-in-4.0
  26. https://processing.org/reference/createfont_
  27. https://py.processing.org/
  28. https://github.com/fathominfo/processing-p5js-mode
  29. https://processing.org/reference/libraries/
  30. https://processing.org/reference/libraries/sound/
  31. https://github.com/processing/processing-contributions
  32. https://github.com/processing/processing4/releases/tag/processing-1309-4.4.9
  33. https://github.com/processing/processing4/pull/1038
  34. https://processing.org/tutorials/gettingstarted/
  35. https://processing.org/reference/mouseX.html
  36. https://processing.org/reference/frameCount.html
  37. https://processing.org/reference/sin_.html
  38. https://processing.org/reference/loadTable_.html
  39. https://processing.org/reference/loadJSONObject_.html
  40. https://www.arduino.cc/education/interactive-art-project/
  41. https://processing.org/examples/noise1d/
  42. http://www.complexification.net/gallery/machines/substrate/
  43. https://thegreatdiscontent.com/interview/joshua-davis/
  44. https://medium.com/processing-foundation/announcing-the-new-p5-js-project-co-leads-qianqian-and-evelyn-88b2ddd744e8
  45. https://github.com/py5coding/py5
  46. https://github.com/quil/quil
  47. https://rhizome.org/editorial/2009/sep/23/interview-with-casey-reas-and-ben-fry/
  48. https://stackoverflow.com/questions/1575248/scala-2d-animation-library
  49. https://android.processing.org/
  50. https://processingfoundation.org/grants
  51. https://medium.com/processing-foundation/announcing-new-roles-at-processing-foundation-d398f849909a
  52. https://processingfoundation.org/advocacy/processing-community-day-2020
  53. https://pcdcph.com/
  54. https://wp.nyu.edu/ltt2024/
  55. https://learningprocessing.com/
  56. https://processing.org/books/
  57. https://p5js.org/education-resources/
  58. https://processingfoundation.org/
  59. http://www.flong.com/archive/texts/essays/statement_netvision_ars/index.html
  60. https://tokyotypedirectorsclub.org/en/award/2005_interactive/
  61. https://www.cooperhewitt.org/national-design-awards/2011-national-design-awards-winners/
  62. https://newsroom.ucla.edu/dept/faculty/casey-reas-shows-work-in-la-gallery-and-receives-lumen-prize
  63. https://processingfoundation.org/fellowships
  64. https://www.benfry.com/writing/archives/204
  65. https://newsroom.ucla.edu/stories/bridging-the-gap-between-art-and-code
  66. https://www.arts.gov/stories/magazine/2018/3/pushing-boundaries-look-visionary-approaches-arts/muse-machine
  67. https://history.siggraph.org/learning/processing-org-programming-for-artists-and-designers-by-reas-and-fry/
  68. https://natureofcode.com/
  69. https://tisch.nyu.edu/about/directory/itp/1984778605.html
  70. https://vimeo.com/60735314
  71. https://www.wired.com/beyond-the-beyond/2015/06/meet-processing-lingua-franca-creative-coding/
  72. https://www.wired.com/2013/10/processing-2-0-a-short-introduction/
  73. https://www.amazon.com/Processing-Programming-Handbook-Designers-Artists/dp/0262182629
  74. https://medium.com/processing-foundation/announcing-processing-foundation-fellowship-2023-mentors-f3cbf07e5515
  75. https://processingfoundation.org/fellowships/fellowships-2021
  76. https://openprocessing.org/sketch/2709819
  77. https://www.moma.org/magazine/articles/658
  78. https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
  79. https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
  80. https://creativecommons.org/licenses/by-nc-sa/4.0/
  81. https://forum.processing.org/one/topic/questions-regarding-open-source-licensing.html
  82. https://processing.org/download
  83. https://github.com/benfry/processing4
  84. https://github.com/processing/processing4/wiki/Legacy-Installation-Instructions-(pre-4.4)
  85. https://github.com/processing/processing4/releases/tag/processing-1310-4.4.10
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.