Processing

Processing is a free, open-source programming language and integrated development environment (IDE) built for the visual arts. Its creators describe it as a “software sketchbook” — a tool for quickly trying out ideas in code the way an artist sketches in a notebook. Built on top of Java, Processing pairs a simplified language with a minimal editor and an instant “Run” button that opens a graphics window, making it possible to draw shapes, animate them, and respond to input within a few lines of code. More than any single feature, Processing’s lasting significance is cultural: it largely launched the modern creative-coding movement and made programming approachable for a generation of artists, designers, and educators.

History and Origins

Processing began in 2001 at the MIT Media Lab, where Casey Reas and Ben Fry were members of the Aesthetics + Computation Group (ACG) led by John Maeda. The group sat at the intersection of graphic design and computer science, a lineage tracing back to Muriel Cooper’s Visible Language Workshop. The direct predecessor was Maeda’s own teaching language, Design By Numbers, which aimed to introduce programming to designers; Reas and Fry set out to build something more capable and open-ended.

The project was originally styled “Proce55ing” — because the obvious domain name was taken — and lived for years at proce55ing.net before moving to processing.org around 2004. Rather than rushing to a formal release, the creators kept Processing in alpha and beta for roughly seven years, refining it through real classroom and studio use. When version 1.0 finally arrived on November 24, 2008, Fry wryly noted that “it only took 162 attempts.” By then Processing had already spread widely through art and design schools.

In 2012, Reas, Fry, and educator Daniel Shiffman founded the Processing Foundation, a nonprofit organization to maintain the software and, crucially, to broaden who gets to participate in code and the arts.

Design Philosophy

Processing was built on a clear and somewhat radical premise: that programming belongs in the visual arts, and that the visual arts have something to teach programming. The Foundation frames its mission as promoting “software literacy within the visual arts, and visual literacy within technology.”

Several principles follow from that goal:

• Sketching over engineering. The workflow is optimized for figuring things out — write a few lines, hit Run, see a result, iterate. The barrier between idea and image is deliberately thin.
• Immediate visual feedback. A program (called a sketch) typically produces a graphics window the moment it runs, so beginners see the consequences of their code instantly rather than parsing console output.
• A gentle on-ramp, not a toy. Processing simplifies Java’s ceremony for newcomers, yet it remains a real, capable environment used for production artwork and installations.
• Openness and community. It is free and open source, with a large library ecosystem and an emphasis on teaching, sharing, and inclusion.

Key Features

A minimal Processing sketch is built around two functions — setup(), which runs once, and draw(), which runs every frame:

1
2
3
4
5
6
7
8

void setup() {
  size(400, 400);
}

void draw() {
  background(0);
  ellipse(mouseX, mouseY, 80, 80);
}

That small program opens a window and draws a circle that follows the mouse — a complete, animated, interactive sketch.

• A drawing-first standard library. Built-in functions cover 2D and 3D shapes, color, typography, images, and transformations, with renderers including an OpenGL-based mode for hardware-accelerated graphics.
• The Processing Development Environment (PDE). A deliberately spare editor with a single prominent Run button, designed to keep beginners focused on their code rather than on tooling.
• Built on the JVM. Because Processing compiles down to Java, sketches are statically typed and can call on the broader Java ecosystem and external libraries when needed.
• Modes for other platforms. Beyond the default Java mode, the community has added an Android mode (foundations built around 2009) and a Python mode (Processing.py), letting the same concepts apply across targets.
• A rich library ecosystem. Contributed libraries extend Processing into sound, computer vision, networking, hardware, and data visualization.

A Family of Descendants

Few teaching languages have spawned as influential a lineage as Processing:

The Arduino connection is especially notable: the wildly popular electronics platform grew out of Wiring, which itself adapted Processing’s editor and language conventions for hardware. In this sense, Processing’s design ideas reached far beyond the screen and into the physical-computing and maker movements.

Evolution

Processing has advanced through several major versions, each modernizing the platform while preserving the sketchbook experience:

• 1.0 (2008) — the first stable release after years of public beta.
• 2.0 (2013) — a new OpenGL-based rendering pipeline.
• 3.0 (2015) — a redesigned editor, with performance and usability improvements among the release’s stated goals.
• 4.0 (2022) — released on the project’s 21st anniversary, targeting Java 17 and modernizing the underlying runtime.

Development continues on the 4.x line under the Processing Foundation, with stable releases such as 4.5.2 arriving in mid-2026. Meanwhile, much of the energy around creative coding on the web has shifted to p5.js, which the Foundation also stewards — making Processing less a single program than an ecosystem of related tools sharing a common philosophy.

Licensing

Processing is free and open source. The core library is released under the GNU LGPL v2.1, while the editor (PDE) and most other components are released under the GNU GPL v2. This split lets people distribute the runtime library with their own work under more permissive terms while keeping the broader project copyleft.

Why It Matters

Processing’s impact is out of all proportion to its size. By treating code as a creative medium and prioritizing immediate visual feedback, it gave countless artists, designers, architects, and students their first successful experience of programming — and a reason to keep going. Its descendants thread through some of the most important tools of the past two decades: p5.js carries its ideas to the open web, and Arduino carries them into hardware and the maker movement.

Just as importantly, Processing helped legitimize creative coding as a discipline. Works built with it hang in the Museum of Modern Art and have shaped public memorials and major museum exhibitions. For a language that started as a graduate-school sketchbook, Processing’s real achievement was to convince a generation that writing software could be an act of art — and that learning to code could begin not with abstraction, but with a circle on a screen.