Creative Coding Tools for Media Art — A Critical Review from Production Practice

Seven tools dominate the conversation — Processing, p5.js, openFrameworks, TouchDesigner, Cables.gl, Notch, Max/MSP. Most comparisons read like feature lists. This is not that. What follows is a production-based assessment of which tools actually hold up over time, written from the perspective of artists building work for galleries and institutions — not browsers. Nordic context included.

What Makes a Tool Exhibition-Ready? A Framework

Exhibition-readiness is not about features. It is about what the tool does when you are not there to fix it.

The framing matters. When I look at how competitors write about creative coding tools — and I have read them all, including the Juno promo article that dominated Google in late 2025 — the criteria are consistently the same: learning curve, community size, beginner-friendliness. These are valid for students. They are the wrong questions for a working media artist commissioning a three-year installation at a kunsthalle.

Timo Toots’s Memopol series (Estonia, Golden Nica for Interactive Art, Prix Ars Electronica 2012) ran across multiple venues over years. That kind of durability is not achieved by picking the easiest tool to learn. It requires thinking ahead about five specific pressures that most reviews skip entirely.

Five criteria for exhibition-readiness:

1. Stability over time — Does the tool behave identically on a locked-down computer two years after initial deployment? Or does the licensing server, the auto-updater, or a changed API break it silently?
2. Hardware integration — How cleanly does the tool talk to sensor arrays, DMX dimmers, video routing hardware, projectors? Through native support or through fragile third-party bridges?
3. Licence risk — What happens if the company disappears, changes pricing, or revokes access? Open-source tools have no commercial risk. Commercial tools have varying degrees of it.
4. Community longevity — Not just size. Longevity. A forum with a hundred thousand posts from 2015 is not the same as a forum with active responses this week.
5. Headless render capability — Can the tool run without a monitor, keyboard, or user interaction for 18 months straight? Not all of them can.

The table below gives a first pass. Detail follows in the individual assessments.

The Seven Major Players — Individual Assessments

Seven tools. Not all equally relevant to every context. The assessments below are weighted accordingly — TouchDesigner and Processing get more space because they come up in more conversations. Cables.gl and Notch are shorter because their use-cases are narrower.

Processing and p5.js — The Long-Term Baseline

Processing has been around since 2001. Created by Casey Reas and Ben Fry at MIT, it has outlasted tools that launched with more fanfare and better funding. That track record is not accidental.

For screen-based, code-first work — generative graphics, interactive displays, data visualisations running on a museum kiosk — Processing remains the most defensible choice when the brief includes the word “years”. The codebase is open source under LGPL/GPL. The GitHub repository (github.com/processing/processing4) receives regular maintenance. There is no subscription to renew, no licence server to phone home. A locked-down installation running Processing 4.x today has every reasonable chance of running the same sketch in 2030 without modification. Processing remains the best on-ramp into creative coding — but it is the wrong tool for a five-year installation that needs real-time sensor input and GPU-heavy rendering.

The deal-breaker is not bugs. It is architectural ceiling. Processing is single-threaded by default. Its GPU pipeline relies on OpenGL via JOGL, which trails behind modern GPU capabilities. A complex particle system or real-time video composition will hit frame-rate limits that TouchDesigner or openFrameworks handles without effort. For Jonas Jongejan (DK), who built immersive light installations including the “Light Leaks” projection at CLICK Festival, the web-based workflow of p5.js suited the context. For a permanently installed work with physical sensor input and multi-channel video, Processing starts to creak.

p5.js is the JavaScript sibling — browser-native, approachable, actively developed toward the 2.0 release (available as opt-in from early 2025). The community is large and growing, particularly in education. The problem for gallery installation is fundamental: browser dependencies are not stable over years. A JavaScript runtime is a moving target. For a piece running on a gallery’s locked-down kiosk computer, p5.js introduces brittleness that Processing on the desktop avoids. Use p5.js for participatory web-based works; use Processing when the work needs to survive a macOS update cycle undisturbed.

openFrameworks — C++ for Serious Work

openFrameworks is not for everyone. The learning investment is substantial: you are writing C++, managing memory manually (or carefully, with modern C++ practices), and configuring build environments that require patience. The first hour is not pleasant.

Past that threshold, it is the most capable open-source option on this list. openFrameworks runs on Windows, macOS, Linux, iOS, and Android. The latest stable release is 0.12.1 (repository last updated May 2025), with active maintenance confirmed. Memo Akten (UK/GR) has built his practice substantially in openFrameworks — the real-time physics and fluid simulations in his early installations required the GPU access and performance headroom that oF provides natively.

The hardware integration story is excellent. The ofxOSC addon is mature. Serial communication with microcontrollers is well-documented. The MIT licence means zero commercial risk. For a long-running installation that needs to run headless, on Linux, processing OpenCV camera input at 60fps — openFrameworks is the correct answer. Not the easiest. The correct one.

Community health: the forum at forum.openframeworks.cc shows reduced activity compared to its peak (roughly 2012–2018), but critical questions still get answered. The core library continues to receive maintenance even if the pace of new feature development has slowed. That is fine for production use — stability is more valuable than novelty.

TouchDesigner — The Industry Standard with Caveats

TouchDesigner is the dominant tool in professional AV production, immersive installation, and live performance. If you are working with a major gallery’s technical team in 2025, there is a better-than-even chance they know TouchDesigner. The operator-based, node-driven workflow handles complex signal routing — video, audio, MIDI, DMX, OSC, NDI, Syphon/Spout — in ways that would require significant custom code in any other tool. The 2025 release added the first new operator family in over a decade (Point Operators / POPs), NVIDIA Blackwell GPU support, and improved Python 3.12 integration.

The commercial licence is USD 600 for a standard commercial key; USD 900 for a floating cloud licence. An educational licence costs USD 300. Prices as of 2025 per derivative.ca. This pricing is reasonable for a professional studio. It is a meaningful barrier for an independent artist building a single permanent installation.

Now the caveat that most TD coverage omits. Cloud floating licences renew every nine minutes over the internet. If the gallery has unstable connectivity — a rural kunsthalle, a museum in a basement, a temporary venue in a converted warehouse — the cloud licence will stop the installation mid-run. Derivative offers a hardware dongle as an alternative, which solves the problem but adds cost and a physical dependency. The standard (non-cloud) commercial key requires internet only for initial activation; after that, it works offline. But this architectural detail is rarely explained to artists at the point of purchase, and the consequences of getting it wrong during an opening are severe.

HC Gilje (NO) — who developed the free Video Projection Tool (VPT) and has built large-scale projection installations since the mid-2000s — has worked primarily in Max/MSP and Jitter rather than TouchDesigner, precisely because Max’s perpetual licence avoids this class of risk. That is a production decision, not a capability one.

Cables.gl — Browser-Native, Real Limitations

Cables.gl is free. Genuinely free — MIT-licensed, no freemium tiers, sustained by Patreon supporters. The node-based WebGL/WebGPU patching environment runs in a browser and exports to standalone HTML/JavaScript. For web-based interactive works, participatory gallery installations where audience members use their own phones, or educational projects, it punches well above its resource level.

The limitation is not quality. It is context. A gallery installation running Cables.gl is running a browser runtime, which means it inherits all browser dependencies, security update cycles, and WebGL API versioning issues. For a piece meant to run on a dedicated industrial PC for two years without maintenance: this is a fragile stack. OSC support requires workarounds. Native DMX is absent. Hardware integration is limited to what browser APIs expose. Cables.gl is the right tool for the web gallery, wrong for the physical gallery.

Notch — Windows-Only, Closing Deals

Notch occupies a specific niche: high-production live events, broadcast, and theatrical productions where a 3D-capable real-time renderer needs to integrate with a media server. The builder licence is subscription-based; playback (block) licences for fixed installations run around £500–£995 depending on output resolution. Windows-only. No Linux, no macOS. That immediately rules it out for any installation running on Mac hardware or a headless Linux box.

The community is professional and relatively small. Notch is excellent when the brief is a touring LED wall installation or a brand activation. For an independent artist building a museum piece with a three-year run: the Windows-only constraint, the subscription cost, and the relative newness of the platform (no twenty-year track record) make it a higher-risk choice than it appears from the demo reels.

Max/MSP — The Audio-Visual Veteran

Max/MSP has been Cycling ’74’s flagship since the late 1980s. Max 8 is available as a monthly or annual subscription, or as a perpetual licence — exact current pricing at cycling74.com/shop. The perpetual option matters for the same reason it matters everywhere: subscription termination does not kill a running installation.

The audio side remains unmatched. For installations where sound is not decoration but structure — generative audio reacting to sensor data, spatial audio routing, live synthesis — Max is the right environment. The Jitter module handles video and 3D. HC Gilje’s work in Norway demonstrates what a sustained practice in Max looks like: the Video Projection Tool, built in Max, has been used by hundreds of artists internationally.

The deal-breaker is the learning model. Max is expensive in time. The patching paradigm is powerful but idiosyncratic — experienced programmers sometimes find it harder than beginners, because the object-based visual logic resists the linear habits of code. Budget at least three months of serious work before the first production-ready patch. The community on the Cycling ’74 forum is active and technically sophisticated. ml.star (the Max machine learning package) provides classification and regression tools, but these require considerable expertise to stabilise for unattended operation.

Community Health 2025/2026 — Who’s Growing, Who’s Coasting

Numbers matter here. “Active community” is the most overused phrase in creative coding coverage. Let’s be more precise.

Processing — the processing4 GitHub repository shows ongoing maintenance activity as of early 2025. The forum at discourse.processing.org is active. The ecosystem is mature rather than growing: the Foundation’s energy has shifted toward p5.js 2.0, which is where new development investment is concentrated. Processing itself is in a maintenance phase — which for production stability is actually good news.

p5.js — the most actively developed member of the Processing family right now. The p5.js 2.0 release timeline has been in motion through 2025, with the beta available as opt-in from early April 2025 and 1.x support continuing in parallel for at least a year. The Processing Foundation’s 2025 pr05 grant theme — “Building Bridges” — signals investment in ecosystem interoperability. Community health: strong and growing, especially in the education sector. Community activity data for exact commit frequencies as of April 2026 requires direct verification at github.com/processing/p5.js before publish.

openFrameworks — peak community activity was roughly 2012–2018. The forum is quieter now. The repository is maintained (last update confirmed May 2025). This is the “mature open-source” pattern: core functionality stable, major new features infrequent, issues addressed but slowly. Not a problem for production use. A problem if you need cutting-edge GPU features implemented quickly.

TouchDesigner — the forum at forum.derivative.ca is the most commercially active community on this list, with significant professional membership. Activity since the 2024 pricing restructuring has been mixed — some long-term users voiced frustration at the price increase, and threads tracking this are visible in the general discussion section. Community activity data since January 2025 requires direct verification before publish. The commercial ecosystem (courses, plugins, studios) is robust.

Cables.gl — small but engaged community on Discord. Given the tool’s free, MIT-licensed status and its ongoing development (June 2025 release documented on blog.cables.gl), it is growing, not coasting. The community is younger and more web-oriented than the TD or oF communities.

Notch — professional and niche. LinkedIn-heavy. Not a forum culture. Community health is tied directly to the high-production events industry, which means it is healthy when touring productions are active and quieter in off-seasons.

Max/MSP — the Cycling ’74 forum is one of the oldest active creative-coding communities on the internet. Longevity counts. The community has survived multiple ownership changes (cycling74 was acquired by Ableton in 2017) and remains technically engaged. Community activity data for precise monthly metrics as of April 2026 requires direct verification before publish.

Workflow Integration in the Gallery Context

A tool running in isolation is rarely the whole installation. The gallery stack typically involves video routing software (Madmapper, Resolume Avenue, Millumin), projection or LED systems receiving DMX or Art-Net, and sometimes external sensor hardware communicating via OSC or serial.

NDI (Network Device Interface) sends video over IP. TouchDesigner has native NDI In/Out TOP operators — this is one of its strongest practical advantages in multi-system installations. Notch integrates with Resolume via NDI. openFrameworks requires an addon (ofxNDI), which is maintained but not official. Processing and p5.js have no native NDI.

Syphon (macOS) and Spout (Windows) share GPU textures between applications at minimal performance cost. TouchDesigner supports both natively. This matters for installations where the creative tool drives content but an external mapper (Madmapper, MilLumin) handles projection geometry. openFrameworks has the ofxSyphon and ofxSpout addons — solid but requiring manual integration.

DMX and Art-Net control lighting directly. TouchDesigner has a native DMX Out CHOP and Art-Net support. Max/MSP handles DMX via external objects (e.g., sadam.artnet). openFrameworks has ofxArtNet. Processing requires third-party libraries and the results are workable but less polished than the TD implementation.

OSC (Open Sound Control) is the lingua franca of creative tool communication. Every tool on this list speaks OSC, though quality varies. Max and TouchDesigner have mature, well-documented OSC implementations. Processing’s oscP5 library works reliably. p5.js OSC in a gallery context requires a Node.js bridge, which adds complexity for unattended operation.

For headless rendering — the installation running without a monitor after opening night — the picture is uneven. openFrameworks on Linux is the most reliable headless option. TouchDesigner can run headless but requires care with the licence setup. Processing with a virtual framebuffer (Xvfb on Linux) works but is fragile. p5.js via Node.js is possible but not common in production.

AI Integration 2025/2026 — Production-Ready or Marketing?

Honest answer: it depends which kind of AI, and which scenario.

There are three distinct categories of AI integration in creative coding tools, and conflating them produces the kind of breathless coverage that K4 (the Juno promo article reviewed for this piece) exemplifies. That article starts from a “best for no-code interactive art” recommendation and works backward — a marketing logic, not a production logic. The categories:

Category A: Native AI in the tool itself. TouchDesigner 2025 added the tdPyEnvManager and Thread Manager, enabling running Stable Diffusion models and other Python-based ML workflows within the patch. NVIDIA’s Blackwell GPU support (50-series) activates the Background, Denoise, and Upscaler TOPs. These are real, production-ready additions — but they require a high-end NVIDIA GPU and significant technical investment to stabilise. “Production-ready” means: a studio with a dedicated technical artist can build and maintain it. It does not mean “drop into an unattended installation and walk away”.

Category B: Plugin-based external models. p5.js with ml5.js provides accessible ML classification (image recognition, pose estimation) in the browser. For interactive participatory works — a visitor stands in front of a camera, the sketch responds — this is genuinely useful. The browser limitation is real: ml5.js at current capability is not stable enough for unattended 24/7 gallery operation. Max/MSP’s ml.star package provides classification and regression in the patching environment; the toolkit has been available since December 2017 but production stabilisation for unattended runs requires expert knowledge. A step-by-step guide on production-grade ml.lib use appeared in January 2025 — indicating that the community is still actively developing best practices, not that the tools are plug-and-play.

Category C: Manual combination (GLSL + ML output). Anna Ridler’s Mosaic Virus (2018/2019) trained a GAN on ten thousand tulip photographs and used the output to generate video controlled by Bitcoin price fluctuations. The ML component ran offline; the generative video ran as a single-channel installation. This is not “AI in the tool” — it is an artist who understands both ML training pipelines and media art installation separately, combining them with precision. Ridler’s practice shows what this actually requires: months of dataset curation, training time, and careful output integration. Not a feature toggle.

For unattended Dauerinstallationen running over years: AI features are not production-ready in 2025/2026. The tooling moves too fast, model APIs change, GPU driver updates break inference pipelines in ways that are hard to predict. The safest approach is to use AI in the pre-production phase — generate assets, train models, bake outputs — and deploy static or scripted results in the installation itself. This is not a limitation of creativity. It is an honest assessment of infrastructure maturity.

Migration Paths — When to Switch Tools

The tool switch is almost always delayed too long. Here is how to recognise when it is necessary.

Switching tools is expensive. You lose institutional knowledge, community support specific to the previous tool, and potentially years of reusable code. The instinct to stay with a familiar environment is rational — up to a point. Three scenarios where the switch is not optional:

Scenario 1: Processing → TouchDesigner. The signal is clear: you are building an installation that needs real-time sensor input (depth cameras, LIDAR, body tracking) feeding into video processing and hardware output (DMX, projector warping, multi-screen routing). Processing can handle some of this via libraries. It cannot handle all of it cleanly, and the integration effort grows exponentially with complexity. When a project requires more than two hardware inputs talking to each other in real time, and the output goes to more than one surface, TouchDesigner’s signal-graph architecture pays for itself in development time within the first week. The cost: licensing, and learning the TD operator model from scratch. The false economy: forcing Processing to do what TD does natively, then spending the opening week firefighting.

Scenario 2: TouchDesigner → openFrameworks. Less common, but real. The scenario: a long-running installation at an institution that cannot guarantee internet connectivity for licence renewal, or where the museum’s technical staff cannot support commercial licensing renewals over a five-year run. Alternatively: the installation requires Linux (perhaps for security or budget reasons), which TD does not support. openFrameworks handles both cases — MIT licence, full Linux support, no licence server. What you lose: TD’s operator library, the timeline tools, the ease of NDI routing. What you gain: zero commercial risk, full platform control. This migration is hard. Budget for it accordingly.

Scenario 3: Cables.gl → a native tool. The installation started as a web-based prototype in Cables.gl, it worked in the browser demo, and now the brief has changed: the gallery wants it running on a dedicated machine, offline, for two years. This is not a Cables.gl problem — the tool delivered what it promised. The browser runtime is simply not the right substrate for an offline permanent installation. Port the logic to Processing (if screen-based and code-first) or TouchDesigner (if hardware integration is required). Expect to rewrite rather than port directly.

A note on vvvv gamma: the 2023 5.0 and 2024 6.0 releases introduced significant architectural changes, and user reports on discourse.vvvv.org document cases of older patches failing to open in newer gamma versions — the migration burden is real and ongoing. vvvv gamma is a capable node-based environment with good scalability, but anyone investing in it for long-running installations should document their version and plan for active maintenance.

The artist who stays on Processing because they know it — despite a brief that requires real-time multi-channel routing — will pay for that comfort in production hours. But the artist who switches to TouchDesigner six months before a complex installation without understanding the licence architecture will face a different kind of crisis. Neither tool fails. The selection process does.

Long-Term Maintenance — The Tool Over Five Years

The most important question in tool selection is the one no comparison article asks: what does this installation look like in 2031?

Consider the variables. The operating system will update. GPU drivers will change. The tool’s own developers may release breaking updates, change their licensing model, or cease operations. The person who built the work may not be reachable. The institution may not have technical staff who understand the tool.

Open-source tools with long histories are objectively safer in this context. Processing has been maintained since 2001 — over two decades. openFrameworks since 2004. Neither has a commercial entity that can be acquired, pivoted, or shut down in a way that affects the codebase. A Processing sketch written in 2010 runs today with minimal adjustment. That is a twenty-year track record. No commercial tool on this list can claim it.

TouchDesigner’s commercial history is longer than it appears — Derivative was founded in 1999 — and the tool has not broken backwards compatibility in the way some critics suggest. However, the licence dependency is a genuine architectural risk. A gallery running a TouchDesigner installation on a machine that loses internet access during an Ableton integration rollout — or during any number of unforeseen network events — faces a licensing interruption that is structurally impossible with an open-source tool.

Notch and Cables.gl are both relatively young. Notch’s earliest professional deployments date to around 2014–2015. Cables.gl’s public launch was around 2015–2016. Neither has a twenty-year track record. For a five-year installation, this means accepting more uncertainty about maintenance trajectory.

vvvv gamma — as noted above — has introduced breaking changes between major versions. The 2023 rewrite moved to a fundamentally different architecture, and legacy vvvv beta patches do not migrate automatically to gamma. Users documenting this on the forum as recently as 2024 are still working through edge cases. This does not make vvvv unsuitable — but it means active version management is mandatory, not optional.

A practical ranking for long-running (5-year) unattended installations, from highest to lowest confidence: openFrameworks (Linux, MIT) → Processing (mature, open-source) → Max/MSP with perpetual licence → TouchDesigner with dongle licence → TouchDesigner with cloud licence → Cables.gl on dedicated Node.js setup → Notch (Windows-only, subscription risk). This ranking is specific to the Dauerinstallation scenario. For live performance, the ranking looks completely different — and TouchDesigner would move to the top without argument.

The discipline is this: match the tool to the scenario before you begin, not after the brief is locked. A wrong tool selection, discovered three months before opening, costs far more to correct than the hours spent on the decision at the start.

Frequently Asked Questions