I’m looking for a way to use Processing 4 without relying on the PDE. Specifically, I’d like to know if a processing-java binary is distributed through any package manager (e.g., Homebrew, apt, pacman, etc.). I haven’t found any documentation in the repository about working with Processing in an editor‑agnostic manner, and I’d prefer to avoid using the built‑in PDE.
Any pointers or recommendations would be greatly appreciated—thanks!
Are you going to run your Processing files from the command-line? This is what I have for my mac:
Command line edition for Processing 4.4.10 (Java Mode)
--help Show this help text. Congratulations.
--sketch=<name> Specify the sketch folder (required)
--output=<name> Specify the output folder (optional and
cannot be the same as the sketch folder.)
--force The sketch will not build if the output
folder already exists, because the contents
will be replaced. This option erases the
folder first. Use with extreme caution!
--build Preprocess and compile a sketch into .class files.
--run Preprocess, compile, and run a sketch.
--present Preprocess, compile, and run a sketch in presentation mode.
--export Export an application.
--variant Specify the platform and architecture (Export only).
--no-java Do not embed Java.
Starting with 4.0, the --platform option has been removed
because of the variety of platforms and architectures now available.
Use the --variant option instead, for instance:
variant platform
------------- ---------------------------
macos-x86_64 macOS (Intel 64-bit)
macos-aarch64 macOS (Apple Silicon)
windows-amd64 Windows (Intel 64-bit)
linux-amd64 Linux (Intel 64-bit)
linux-arm Linux (Raspberry Pi 32-bit)
linux-aarch64 Linux (Raspberry Pi 64-bit)
The --build, --run, --present, or --export must be the final parameter
passed to Processing. Arguments passed following one of those four will
be passed through to the sketch itself, and therefore available to the
sketch via the 'args' field. To pass options understood by PApplet.main(),
write a custom main() method so that the preprocessor does not add one.
https://github.com/processing/processing/wiki/Command-Line
Have you tried installing it from the Processing IDE menubar:
Hi @SNitaine! We’ve been hard at work trying to decouple Processing core from the editor and make everything a bit more modular. As of now that work is not yet ready though!
So far we have the following:
We have core published to maven central as a standard Java library.
We have the Visual Studio Code plugin
As for distributing processing-java as a standalone, if you look under the hood of that binary you will see that is just a wrapper around running the PDE binary with some extra arguments, so a decoupling is unlikely there.
Thanks for the info. I haven’t tried it, I am on a new machine and I haven’t downloaded the PDE yet… I am trying not to 
Oh I wasn’t aware that it is just a wrapper around running the PDE binary. I can only imagine how much hard work that goes into decoupling Processing. I will try and follow the process on GitHub.
Thanks, I will try and take a look at the maven core.
Not sure why you’re allergic to the editor, but alternatively you could get your hands on the executable and access that with the command line. Which operating system are you using?
I can’t recall where I got the executable, but I tested it and it works.
Hello @SNitaine,
Extracted from above link:
You can use processing.exe cli instead of processing-java.exe everything should be the same as before.
Editor-agnostic guidance that may work for a Windows 10 and Processing 4.4.10 environment:
Download the portable ZIP version:
Releases · processing/processing4 · GitHub
You will have to (makes life easier) add processing.exe to your environment path.
This is the command-line for --help:
D:\Users\GLV\Documents\P4>processing cli --help | more
D:\Users\GLV\Documents\P4>processing cli --sketch=alpha_gradients_1_0_0 --runNote the usage of cli in the above!
Folders structure will certainly be different on your PC.
You may accidentally launch the PDE if you make mistakes on the command-line!
If you are comfortable with command-line this is going to be fun!
You may also consider perusing the older versions of Processing for one that includes the processing-java.exe … for use with that version of course!
Have fun!
:)
I’m unclear about the availability of processing-java.exe. Is there a website where this may be downloaded? Is it platform specific, ie will a mac version run on Windows? Apparently Linux requires processing-cli ; if so, where can we get a copy? I’ve read on one of the github sites that processing-java won’t run on Linux.
Hello @SNitaine ,
This will set you free!
All you need is Java and the Processing core and libraries (included them all here):
And also the natives:
javac -Xlint:all -cp .\windows-amd64\lib\core-4.4.10.jar *.java
java -cp .\windows-amd64\lib\*;. -Djava.library.path=.\windows-amd64\lib\natives\windows-amd64 Sketch
Notes:
PATH.core-4.4.10.jar and any other required libraries are in the specified windows-amd64\lib directory.sketch.java (was generated by PDE and used as the template):
/* autogenerated by Processing revision 1310 on 2025-11-08 */
import processing.core.PApplet;
import processing.core.*;
import processing.data.*;
import processing.event.*;
import processing.opengl.*;
import java.util.HashMap;
import java.util.ArrayList;
import java.io.File;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
public class Sketch extends PApplet
{
Helper helper;
public void setup()
{
helper = new Helper();
helper.printMessage();
println();
println("***** Sketch Output *****");
println();
/* size commented out by preprocessor */ ;
println("sketchPath:", sketchPath());
}
public void draw()
{
background(0, 255, 0);
}
public void settings()
{
size(300, 125, P3D);
}
static public void main(String[] passedArgs)
{
println("In the beginning...");
println();
printArray(passedArgs);
println();
String[] appletArgs = new String[] { "Sketch" };
if (passedArgs != null)
{
PApplet.main(concat(appletArgs, passedArgs));
}
else
{
PApplet.main(appletArgs);
}
}
}
helper.java:
public class Helper {
public Helper() {
// Constructor (if needed)
System.out.println("I am here to help!");
}
public void printMessage() {
System.out.println("Helper class message!");
}
}
This took me a while to achieve!
At first I extracted the natives from the JAR files as an exercise.
It was much easier to export a project from the PDE and all the core, native and even Java were ready to go to be used for any future self-contained project.
I did use the PDE later to export a project which generated all the necessary files (Processing core and libraries, natives and Java from Processing) but it was NOT necessary… just a lot easier. I did manage without doing this but it was a challenge and I did learn a lot from it!
The files in the folders can be reduced to a more minimal set.
I will leave that as as an exercise.
I also have the the java compile and run in a batch file:
The above was shared to demonstrate what can be achieved and a personal exploration only.
It is not intended to be a complete working example or represent best practices.
There are many ways to build these projects!
Have fun!
:)
processing-java has been renamed to processing cli so we no longer need to distribute multiple binaries/scripts and works on all platforms. You can find more documentation here: Environment / Processing.org
What you have done appears to me to be similar to what is required to run Processing code in Eclipse: https://discourse.processing.org/t/why-p2d-not-working-inside-eclipse-when-i-using-the-processing-core/45930/8 , although in this thread far fewer jar files and libraries were required compared to what you describe. I’m curious about the size of the app which you created if it is exported as a standalone. As I recall the OP did not tell us what operating system he was using; therefore, we might need to try and reproduce what you achieved on other platforms.
I have been working with all the other IDEs such as Eclipse, IntelliJ, NetBeans and recently VS Code for some time now.
This was a fun exercise for me to do this with just Java and Windows Terminal (Command Prompt). I examined all the JAR files and even extracted the native DLLs. Much of this was by rote for me and I wanted to see what’s new with the recent Processing versions. And work my brains a bit!
Yes indeed!
I was not focused on slimming it down or go as far as packaging it into a JAR file or creating a standalone executable.
I had fun exploring this and even extracting the native DLLs!
My current projects are modifying the Processing source code and building custom versions.
I use VS Code and build, compile, run and package on the Windows Terminal(PowerShell).
All the necessary files are in an export from the PDE (even a blank sketch!) and that can be used by anyone as a starting point. I have a slimmed down version for my personal use.
My exploration was brief, superficial, and solely for personal development. The topic has sparked my interest, and now I’m focused on established methods and best practices. Development methods are both varied and standardized, and I encourage individual investigation.
:)
Hello @stefterv,
Clearly I am out of my element but learning!
I made some updates after revisiting this.
I took on the challenge of building a Processing 4.4.10 project with Maven (command-prompt only) using the posted POM, but ran into dependency failures for the P2D renderer.
The issue was that the JOGL 2.5.0 files needed by Processing were not available in the Maven Central repository.
I changed file to 2.6.0 which resolved errors; JAVA2D worked (did not need those files) but P2D/P3D builds gave errors.
The final fix for P2D/P3D was to configure pom.xml to use an alternative repository for the 2.5.0 versions.
** Update ** Version 2
The dependencies are sourced from the Maven Central Repository (for Processing Core and Kotlin) and the JogAmp Repository (for JOGL and GlueGen), which is specified in the <repositories> section.
After all that was said and done these POMs worked for my consumer project:
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- YOUR PROJECT COORDINATES -->
<groupId>com.mycompany.processing</groupId>
<artifactId>my-processing-app</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<!-- Stable JOGL version -->
<jogamp.version>2.5.0</jogamp.version>
</properties>
<dependencies>
<!-- 1. Processing 4.4.10 Core Library -->
<dependency>
<groupId>org.processing</groupId>
<artifactId>core</artifactId>
<version>4.4.10</version>
</dependency>
<!-- 2. Kotlin Standard Library -->
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-stdlib</artifactId>
<version>2.0.20</version>
<scope>compile</scope>
</dependency>
<!-- 3. JOGL 2.5.0 Dependencies (Set to 'compile' for successful application build) -->
<dependency>
<groupId>org.jogamp.jogl</groupId>
<artifactId>jogl-all-main</artifactId>
<version>${jogamp.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.jogamp.gluegen</groupId>
<artifactId>gluegen-rt-main</artifactId>
<version>${jogamp.version}</version>
<scope>compile</scope>
</dependency>
</dependencies>
<!-- Repositories for JOGL (Required to find the jogamp artifacts) -->
<repositories>
<repository>
<id>jogamp-all</id>
<name>JogAmp Maven Repository</name>
<url>https://jogamp.org/deployment/maven/</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<build>
<plugins>
<!-- 1. Copies native DLL/SO files to target/natives -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>3.6.1</version>
<executions>
<execution>
<id>copy-natives</id>
<phase>process-resources</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/natives</outputDirectory>
<includeGroupIds>org.jogamp</includeGroupIds>
<excludeTransitive>true</excludeTransitive>
<stripVersion>true</stripVersion>
</configuration>
</execution>
</executions>
</plugin>
<!-- 2. Creates a single executable JAR (Shade Plugin) -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.5.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.mycompany.processing.App</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.mycompany.processing</groupId>
<artifactId>my-processing-app</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<jogamp.version>2.5.0</jogamp.version>
</properties>
<dependencies>
<dependency>
<groupId>org.processing</groupId>
<artifactId>core</artifactId>
<version>4.4.10</version>
</dependency>
<dependency>
<groupId>org.jogamp.jogl</groupId>
<artifactId>jogl-all-main</artifactId>
<version>${jogamp.version}</version>
</dependency>
<dependency>
<groupId>org.jogamp.gluegen</groupId>
<artifactId>gluegen-rt-main</artifactId>
<version>${jogamp.version}</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>jogamp-maven-path</id>
<name>JogAmp Maven Path</name>
<url>https://jogamp.org/deployment/maven/</url>
</repository>
<repository>
<id>scijava.public</id>
<name>SciJava Public</name>
<url>https://maven.scijava.org/content/groups/public</url>
</repository>
</repositories>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>3.6.1</version>
<executions>
<execution>
<id>copy-natives</id>
<phase>process-resources</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/natives</outputDirectory>
<includeGroupIds>org.jogamp</includeGroupIds>
<excludeTransitive>true</excludeTransitive>
<stripVersion>true</stripVersion>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.5.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.mycompany.processing.App</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
@stefterv , Is this something I should submit as an issue?
Some notes on my development process:
I collaborated with Google Gemini and ChatGPT to guide me through the maven build and resolve the JOGL dependency conflict and it was initially very frustrating. The AI tools offered solutions, alternatives, dead ends, incorrect information, iteration loops and the process required me to persistently validate, correct, refine and simplify instructions to overcome these hurdles, finally resulting in a working configuration for my "consumer project*.
I still needed to do a final edit as it missed out on some important details.
At one point Google Gemini even stated this incorrect information:
My source for the availability of 4.5.4 is the Maven Central Repository , which is the canonical source for Maven dependencies:
- Artifact:
org.processing:core- Version:
4.5.4- URL:
https://repo1.maven.org/maven2/org/processing/core/(You can check this URL; the directory listing confirms4.5.4is available.)
I checked and it is not there! It later corrected itself once I challenged this.
This was a challenging exercise and I certainly learned a lot along the way.
:)