processing
diff --git a/.gitignore b/.gitignore
@@ -139,6 +139,8 @@ generated/
 /java/gradle/build
 /core/examples/build
 /java/gradle/example/.processing
+
+libprocessing/ffi/include/*
 /app/windows/obj
 /java/android/example/build
 /java/android/example/.processing

diff --git a/.gitmodules b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "libprocessing"]
+	path = libprocessing
+	url = https://github.com/processing/libprocessing
diff --git a/BUILD.md b/BUILD.md
@@ -23,6 +23,16 @@ _**Note:** A paid subscription is **not** required. Everything needed to build a
 > [!TIP]
 > If you encounter any issues with this process, Read the [Troubleshooting and Setup Tips for IntelliJ IDEA](#troubleshooting-and-setup-tips-intellij-idea)
 
+1. Clone the Processing4 repository to your machine locally
+1. Open the cloned repository in IntelliJ IDEA CE
+1. When prompted, select **Trust Project**. You can preview the project in Safe Mode but you won't be able to build Processing.
+1. IntelliJ may ask if you want to load Gradle project. If you allow this, make sure you are using JDK version 17.
+1. In the main menu, go to File > Project Structure > Project Settings > Project.
+1. In the SDK Dropdown option, select a JDK version 17 or Download the jdk
+1. Click the green Run Icon in the top right of the window. This is also where you can find the option to debug Processing. 
+1. Logs can be found in the `Build` or `Debug` pane on the bottom left of the window
+
+
 ## VSCode
 1. Clone the Processing4 repository to your machine locally
 1. Open the cloned repository in VScode
@@ -46,7 +56,7 @@ If you don't have them installed, you will need to install [Git](https://git-scm
 
 1. **Clone the repository:**
     ```bash
-    git clone https://github.com/processing/processing4.git
+    git clone --recursive https://github.com/processing/processing4.git
     cd processing4
     ```
 
@@ -58,8 +68,49 @@ If you don't have them installed, you will need to install [Git](https://git-scm
     - [macOS (Apple Silicon)](https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_aarch64_mac_hotspot_17.0.15_6.pkg)
     - [Other platforms](https://adoptium.net/temurin/releases/?package=jdk&version=17&os=any&arch=any)
 
+### macOS:
+```bash
+brew install --cask temurin@17
+````
+
+### Windows (using winget):
+```bash
+winget install --id=EclipseAdoptium.Temurin.17.JDK  -e
+```
+
+### SDKMAN!
+
+[SDKMAN!](https://sdkman.io/) is a useful tool for developers working on multiple versions of the JVM.
+
+## WebGPU Support (Optional)
+
+To build Processing with the experimental WebGPU renderer, you need JDK 25, Rust, and jextract.
+
+### Install Temurin JDK 25
+
+```bash
+brew install --cask temurin@25    # macOS
+```
+
+### Install `jextract`
+
+`jextract` generates Java bindings from C header files.
+You can download it [here](https://jdk.java.net/jextract/) or install it using SDKMAN!:
+
+```bash
+sdk install jextract
+````
+
+### Build with WebGPU
+
+```bash
+./gradlew build -PenableWebGPU=true
+```
+
 3. **Set the `JAVA_HOME` environment variable:**
 
+It may be necessary to set the `JAVA_HOME` environment variable to point to your Temurin JDK installation.
+
     ```bash
     export JAVA_HOME=/path/to/temurin/jdk-17.0.15+6/
     ```
@@ -142,32 +193,24 @@ If you’re building Processing using IntelliJ IDEA and something’s not workin
 
 ### Use the Correct JDK (temurin-17)
 
-Make sure IntelliJ is using **temurin-17**. Some users have reported issues with other distributions.
-
-#### 1. Set the Project SDK
+Make sure IntelliJ is using **temurin-17**, not another version. If building with WebGPU (`-PenableWebGPU=true`), use **temurin-25** instead.
 
-1. Go to **`File > Project Structure > Project`**
-1. Set the **`Project SDK`** to **`temurin-17`**
+1. Go to **File > Project Structure > Project**
+2. Set the **Project SDK** to:    `temurin-17 java version "17.0.15"`
 
 ![JDK Selection](.github/media/troubleshooting-Intellij-setting-djk-version-manually.png)
 
-If Temurin 17 is not on the list, you should install it first:
-
-1. Select the **`Download JDK...`** option from the menu  
-1. Pick **Version**: **`17`**, **Vendor**: **`Eclipse Temurin (AdoptOpenJDK HotSpot)`**
+If it is not already installed, you can download it by:
+1. Clicking the SDK input field and then selecting the `Download JDK...` option from the menu
+2. Select Version: `17`, Vendor: `Eclipse Temurin (AdoptOpenJDK HotSpot)`
 
 <img width="400" alt="JDK Download" src="https://github.com/user-attachments/assets/503a03a4-3e53-4406-9641-2c93e4b45d51" />
 
-#### 2. Set the Gradle JVM
-
-Make sure Gradle also uses Temurin 17:
-
-1. Go to **`Settings > Build, Execution, Deployment > Build Tools > Gradle`**
-1. Set **`Gradle JVM`** to **`temurin-17`**
+![JDK Download](.github/media/troubleshooting-Intellij-download-jdk.png)
 
-_Note: the exact path in settings may vary depending on your version of IntelliJ._
+Now go back to your main window and
+1. Click the green Run Icon in the top right of the window.
 
-<img width="800" alt="Gradle JVM" src="https://github.com/user-attachments/assets/ba620114-e663-4887-89e9-8f26fbfefbb2" />
 
 ### “Duplicate content roots detected”
 

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -54,14 +54,17 @@ compose.desktop {
     application {
         mainClass = "processing.app.ProcessingKt"
 
-        jvmArgs(*listOf(
-            Pair("processing.version", rootProject.version),
-            Pair("processing.revision", findProperty("revision") ?: Int.MAX_VALUE),
-            Pair("processing.contributions.source", "https://contributions.processing.org/contribs"),
-            Pair("processing.download.page", "https://processing.org/download/"),
-            Pair("processing.download.latest", "https://processing.org/download/latest.txt"),
-            Pair("processing.tutorials", "https://processing.org/tutorials/"),
-        ).map { "-D${it.first}=${it.second}" }.toTypedArray())
+        jvmArgs(
+            "--enable-native-access=ALL-UNNAMED",  // Required for Java 25 native library access
+            *listOf(
+                Pair("processing.version", rootProject.version),
+                Pair("processing.revision", findProperty("revision") ?: Int.MAX_VALUE),
+                Pair("processing.contributions.source", "https://contributions.processing.org/contribs"),
+                Pair("processing.download.page", "https://processing.org/download/"),
+                Pair("processing.download.latest", "https://processing.org/download/latest.txt"),
+                Pair("processing.tutorials", "https://processing.org/tutorials/"),
+            ).map { "-D${it.first}=${it.second}" }.toTypedArray()
+        )
 
         nativeDistributions{
             modules("jdk.jdi", "java.compiler", "jdk.accessibility", "jdk.zipfs", "java.management.rmi", "java.scripting", "jdk.httpserver")
@@ -139,11 +142,12 @@ dependencies {
     testImplementation(libs.mockitoKotlin)
     testImplementation(libs.junitJupiter)
     testImplementation(libs.junitJupiterParams)
+
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 
 }
 
 tasks.test {
-    systemProperty("java.awt.headless", "true")
     useJUnitPlatform()
     workingDir = file("build/test")
     workingDir.mkdirs()
@@ -363,12 +367,12 @@ tasks.register<Zip>("zipDistributable"){
     dependsOn("createDistributable", "setExecutablePermissions")
     group = "compose desktop"
 
-    val dir = provider { distributable().destinationDir.get() }
-    val packageName = provider { distributable().packageName.get() }
+    val dir = distributable().destinationDir.get()
+    val packageName = distributable().packageName.get()
 
     from(dir){ eachFile{ permissions{ unix("755") } } }
     archiveBaseName.set(packageName)
-    destinationDirectory.set(layout.dir(provider { dir.get().file("../").asFile }))
+    destinationDirectory.set(dir.file("../").asFile)
 }
 
 afterEvaluate{
@@ -434,12 +438,19 @@ tasks.register<Copy>("includeJavaMode") {
     from(java.configurations.runtimeClasspath)
     into(composeResources("modes/java/mode"))
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    dirPermissions { unix("rwx------") }
 }
+val enableWebGPU = findProperty("enableWebGPU")?.toString()?.toBoolean() ?: false
+
 tasks.register<Copy>("includeJdk") {
-    from(Jvm.current().javaHome.absolutePath)
+    val jdkVersion = if (enableWebGPU) 25 else 17
+    val jdkHome = project.the<JavaToolchainService>().launcherFor {
+        languageVersion.set(JavaLanguageVersion.of(jdkVersion))
+    }.map { it.metadata.installationPath.asFile }
+
+    from(jdkHome)
     destinationDir = composeResources("jdk").get().asFile
 
-    dirPermissions { unix("rwx------") }
     fileTree(destinationDir).files.forEach { file ->
         file.setWritable(true, false)
         file.setReadable(true, false)
@@ -520,15 +531,14 @@ tasks.register("includeProcessingResources"){
     finalizedBy("signResources")
 }
 
-tasks.register("signResources"){
+tasks.register("signResources") {
     onlyIf {
         OperatingSystem.current().isMacOsX
             &&
         compose.desktop.application.nativeDistributions.macOS.signing.sign.get()
     }
     group = "compose desktop"
     val resourcesPath = composeResources("")
-    val entitlements = file("macos/entitlements.plist").absolutePath
 
     // find jars in the resources directory
     val jars = mutableListOf<File>()
@@ -566,8 +576,11 @@ tasks.register("signResources"){
             exclude("*.jar")
             exclude("*.so")
             exclude("*.dll")
-        }.forEach{ file ->
-            Runtime.getRuntime().exec(arrayOf("codesign", "--timestamp", "--force", "--deep", "--options=runtime", "--entitlements", entitlements, "--sign", "Developer ID Application", file.absolutePath))
+        }.forEach{ f ->
+            ProcessBuilder("codesign", "--timestamp", "--force", "--deep", "--options=runtime", "--sign", "Developer ID Application", f.absolutePath)
+                .inheritIO()
+                .start()
+                .waitFor()
         }
         jars.forEach { file ->
             FileOutputStream(File(file.parentFile, file.nameWithoutExtension)).use { fos ->
@@ -618,7 +631,6 @@ tasks.register<Exec>("signApp"){
         "--force",
         "--deep",
         "--options=runtime",
-        "--entitlements", file("macos/entitlements.plist").absolutePath,
         "--sign", "Developer ID Application",
         app)
 }

diff --git a/app/utils/build.gradle.kts b/app/utils/build.gradle.kts
@@ -10,6 +10,7 @@ repositories {
 dependencies {
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 publishing{
@@ -23,4 +24,4 @@ publishing{
 
 tasks.test {
     useJUnitPlatform()
-}
+}
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -12,6 +12,35 @@ plugins {
 // Can be deleted after the migration to Gradle is complete
 layout.buildDirectory = file(".build")
 
+val enableWebGPU = findProperty("enableWebGPU")?.toString()?.toBoolean() ?: false
+val javaVersion = if (enableWebGPU) "25" else "17"
+val kotlinJvmTarget = if (enableWebGPU) {
+    org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_25
+} else {
+    org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+}
+
+allprojects {
+    tasks.withType<JavaCompile>().configureEach {
+        sourceCompatibility = javaVersion
+        targetCompatibility = javaVersion
+    }
+
+    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+        compilerOptions {
+            jvmTarget.set(kotlinJvmTarget)
+        }
+    }
+
+    plugins.withType<JavaPlugin> {
+        extensions.configure<JavaPluginExtension> {
+            toolchain {
+                languageVersion.set(JavaLanguageVersion.of(javaVersion.toInt()))
+            }
+        }
+    }
+}
+
 // Configure the dependencyUpdates task
 tasks {
     dependencyUpdates {

diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    mavenCentral()
+}
diff --git a/buildSrc/src/main/kotlin/processing/gradle/CargoBuildTask.kt b/buildSrc/src/main/kotlin/processing/gradle/CargoBuildTask.kt
@@ -0,0 +1,56 @@
+package processing.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+import org.gradle.process.ExecOperations
+import javax.inject.Inject
+
+abstract class CargoBuildTask : DefaultTask() {
+
+    @get:Inject
+    abstract val execOperations: ExecOperations
+
+    @get:InputDirectory
+    abstract val cargoWorkspaceDir: DirectoryProperty
+
+    @get:Input
+    abstract val manifestPath: Property<String>
+
+    @get:Input
+    abstract val release: Property<Boolean>
+
+    @get:Input
+    abstract val cargoPath: Property<String>
+
+    @get:OutputFile
+    abstract val outputLibrary: RegularFileProperty
+
+    init {
+        group = "rust"
+        description = "Builds Rust library using cargo"
+
+        // release by default
+        release.convention(true)
+    }
+
+    @TaskAction
+    fun build() {
+        val buildType = if (release.get()) "release" else "debug"
+        logger.lifecycle("Building Rust library ($buildType mode)...")
+
+        val args = mutableListOf("build")
+        if (release.get()) {
+            args.add("--release")
+        }
+        args.add("--manifest-path")
+        args.add(manifestPath.get())
+
+        execOperations.exec {
+            workingDir = cargoWorkspaceDir.get().asFile
+            commandLine = listOf(cargoPath.get()) + args
+        }
+    }
+}